diff --git a/include/node.h b/include/node.h index baaed91..1845031 100644 --- a/include/node.h +++ b/include/node.h @@ -1,9 +1,9 @@ /*---------------------------------------------------------------------------------*/ -/* $RCSfile: node.h,v $ */ +/* $RCSfile: node.h,v $ */ /*---------------------------------------------------------------------------------*/ -/* $Revision: 2.6 $ */ +/* $Revision: 2.7 $ */ /* $Name: $ */ -/* $Date: 2003/07/16 00:20:53 $ */ +/* $Date: 2004/08/01 23:18:37 $ */ /* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ @@ -21,7 +21,7 @@ /* GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ -/* along with Foobar; if not, write to the Free Software */ +/* along with LibNode; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /*---------------------------------------------------------------------------------*/ @@ -64,9 +64,9 @@ extern "C" { /* - Différence de profondeur entre la branche la plus courte et - la plus longue d'un arbre. - Le dépassement de ce seuil provoque le rééquilibrage de l'arbre + Différence de profondeur entre la branche la plus courte et + la plus longue d'un arbre. + Le dépassement de ce seuil provoque le rééquilibrage de l'arbre */ #define DEF_MAX_DIF 100 @@ -131,9 +131,9 @@ typedef int NDT_Index_Type; #define ND_INDEX_SUBTYPE_VALUE_UNKNOWN_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_UNKNOWN) #define ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_FIFO) -#define ND_INDEX_SUBTYPE_VALUE_LILO_IS( v) ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v) -#define ND_INDEX_SUBTYPE_VALUE_LIFO_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_LIFO) -#define ND_INDEX_SUBTYPE_VALUE_FILO_IS( v) ND_INDEX_SUBTYPE_LIFO_IS( r, i) +#define ND_INDEX_SUBTYPE_VALUE_LILO_IS( v) ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v) +#define ND_INDEX_SUBTYPE_VALUE_LIFO_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_LIFO) +#define ND_INDEX_SUBTYPE_VALUE_FILO_IS( v) ND_INDEX_SUBTYPE_LIFO_IS( r, i) #define ND_INDEX_SUBTYPE_VALUE_SORTED_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_SORTED) #define ND_INDEX_SUBTYPE_VALUE_UNBALANCED_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_UNBALANCED) #define ND_INDEX_SUBTYPE_VALUE_BALANCED_IS( v) ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_BALANCED) @@ -244,16 +244,16 @@ typedef NDT_Status NDT_Desallocator(void *, void *); typedef struct NDT_Index { - NDT_Index_Type Type; /* Type de la structure (liste, arbre ... ) */ + NDT_Index_Type Type; /* Type de la structure (liste, arbre ... ) */ - long Node_Number; /* Nombre de noeuds dans la structure */ - long Min_Depth; /* Profondeur minimale de l'arbre */ - long Max_Depth; /* Profondeur maximale de l'arbre */ - long Max_Dif; /* Différence maximale autorisée entre la branche la plus courte et la plus longue */ - long Nb_Equ; /* Nombre de réquilibrages réalisés sur l'arbre */ - struct NDT_Node * Head; /* Noeud de tête */ - struct NDT_Node * Tail; /* Noeud de queue */ - struct NDT_Node * Save; /* Pointeur de sauvegarde (utile pour la fonction de restauration) */ + long Node_Number; /* Nombre de noeuds dans la structure */ + long Min_Depth; /* Profondeur minimale de l'arbre */ + long Max_Depth; /* Profondeur maximale de l'arbre */ + long Max_Dif; /* Différence maximale autorisée entre la branche la plus courte et la plus longue */ + long Nb_Equ; /* Nombre de réquilibrages réalisés sur l'arbre */ + struct NDT_Node *Head; /* Noeud de tête */ + struct NDT_Node *Tail; /* Noeud de queue */ + struct NDT_Node *Save; /* Pointeur de sauvegarde (utile pour la fonction de restauration) */ } NDT_Index; @@ -264,19 +264,19 @@ typedef struct NDT_Root // NDT_Root_Type Type; /* Root Structure Type */ // NDT_DataStruct_Type DS_Type; /* Type de la structure (liste, arbre ... ) */ - NDT_Manager *Manager_Ptr; /* Pointeur sur la fonction manager */ - char Manager_Name[NDD_MANAGER_NAME_SIZE_MAX]; /* Nom de la fonction manager */ - NDT_Allocator *Allocator_Ptr; /* Pointeur sur la fonction d'allocation */ - char Allocator_Name[NDD_ALLOCATOR_NAME_SIZE_MAX]; /* Nom de la fonction d'allocation */ - NDT_Desallocator *Desallocator_Ptr; /* Pointeur sur la fonction de désallocation */ - char Desallocator_Name[NDD_DESALLOCATOR_NAME_SIZE_MAX]; /* Nom de la fonction de désallocation */ + NDT_Manager *Manager_Ptr; /* Pointeur sur la fonction manager */ + char Manager_Name[NDD_MANAGER_NAME_SIZE_MAX]; /* Nom de la fonction manager */ + NDT_Allocator *Allocator_Ptr; /* Pointeur sur la fonction d'allocation */ + char Allocator_Name[NDD_ALLOCATOR_NAME_SIZE_MAX]; /* Nom de la fonction d'allocation */ + NDT_Desallocator *Desallocator_Ptr; /* Pointeur sur la fonction de désallocation */ + char Desallocator_Name[NDD_DESALLOCATOR_NAME_SIZE_MAX]; /* Nom de la fonction de désallocation */ - short Own_Value; /* Indique si la structure est propriétaire de ses valeurs */ - void *User; /* Pointeur utilisable librement par l'utilisateur */ + short Own_Value; /* Indique si la structure est propriétaire de ses valeurs */ + void *User; /* Pointeur utilisable librement par l'utilisateur */ - NDT_Index_Nb Index_Nb; - NDT_Index_Nb Index_Open_Count; - NDT_Index Index_Tab[0]; + NDT_Index_Nb Index_Nb; + NDT_Index_Nb Index_Open_Count; + NDT_Index Index_Tab[0]; } NDT_Root; @@ -285,11 +285,11 @@ typedef struct NDT_Root typedef struct NDT_DataStruct { - NDT_Root *Root_Ptr; + NDT_Root *Root_Ptr; - NDT_Manager *Manager_Ptr; /* Manager function pointer */ - NDT_Allocator *Allocator_Ptr; /* Allocator function pointer */ - NDT_Desallocator *Desallocator_Ptr; /* Desallocator function pointer */ + NDT_Manager *Manager_Ptr; /* Manager function pointer */ + NDT_Allocator *Allocator_Ptr; /* Allocator function pointer */ + NDT_Desallocator *Desallocator_Ptr; /* Desallocator function pointer */ } NDT_DataStruct; @@ -304,28 +304,24 @@ typedef struct NDT_Node struct NDT_Node *Parent; struct NDT_Node *Left; struct NDT_Node *Right; - void *Value; + void *Value; } NDT_Node; -char ND_Error_Msg [512]; - - - typedef int NDT_Recursive_Mode; typedef int NDT_Recursive_Depth; typedef int NDT_Recursive_Offset; -#define NDD_RECURSIVE_MODE_UNKNOWN (NDT_Recursive_Mode)0x00 -#define NDD_RECURSIVE_MODE_PARENT (NDT_Recursive_Mode)0x01 -#define NDD_RECURSIVE_MODE_CHILD (NDT_Recursive_Mode)0x02 -#define NDD_RECURSIVE_MODE_PARENT_CHILD (NDT_Recursive_Mode)0x03 +#define NDD_RECURSIVE_MODE_UNKNOWN (NDT_Recursive_Mode)0x00 +#define NDD_RECURSIVE_MODE_PARENT (NDT_Recursive_Mode)0x01 +#define NDD_RECURSIVE_MODE_CHILD (NDT_Recursive_Mode)0x02 +#define NDD_RECURSIVE_MODE_PARENT_CHILD (NDT_Recursive_Mode)0x03 -#define ND_RECURSIVE_PARENT_IS(m) (m & NDD_RECURSIVE_MODE_PARENT) -#define ND_RECURSIVE_CHILD_IS(m) (m & NDD_RECURSIVE_MODE_CHILD) +#define ND_RECURSIVE_PARENT_IS(m) (m & NDD_RECURSIVE_MODE_PARENT) +#define ND_RECURSIVE_CHILD_IS(m) (m & NDD_RECURSIVE_MODE_CHILD) -#define ND_RECURSIVE_PRINT_OFFSET 8 +#define ND_RECURSIVE_PRINT_OFFSET 8 @@ -339,7 +335,7 @@ typedef int NDT_Recursive_Offset; #define ND_Library_Open ND_Library_Open_I #define ND_Library_Close ND_Library_Close_I -#define ND_Library_Stderr_Set ND_Library_Stderr_Set_I +#define ND_Library_StdErr_Set ND_Library_Stderr_Set_I #define ND_DataStruct_Open ND_DataStruct_Open_I #define ND_DataStruct_Close ND_DataStruct_Close_I @@ -355,25 +351,25 @@ typedef int NDT_Recursive_Offset; #define ND_DataStruct_Value_Print ND_DataStruct_Value_Print_I #define ND_DataStruct_Value_Find ND_DataStruct_Value_Find_I -#define ND_Index_Open ND_Index_Open_I -#define ND_Index_Close ND_Index_Close_I -#define ND_Index_Flush ND_Index_Flush_I -#define ND_Index_Check ND_Index_Check_I -#define ND_Index_Convert ND_Index_Convert_I -#define ND_Index_Reorg ND_Index_Reorg_I -#define ND_Index_Traverse_V ND_Index_Traverse_VI -#define ND_Index_Traverse ND_Index_Traverse_I -#define ND_Index_Info_Print ND_Index_Info_Print_I -#define ND_Index_Value_Add ND_Index_Value_Add_I -#define ND_Index_Value_Remove ND_Index_Value_Remove_I -#define ND_Index_Value_Print ND_Index_Value_Print_I -#define ND_Index_Node_Add ND_Index_Node_Add_I -#define ND_Index_Node_Remove ND_Index_Node_Remove_I -#define ND_Index_Node_First_Get ND_Index_Node_First_Get_I -#define ND_Index_Node_Last_Get ND_Index_Node_Last_Get_I -#define ND_Index_Node_Next_Get ND_Index_Node_Next_Get_I -#define ND_Index_Node_Previous_Get ND_Index_Node_Previous_Get_I -#define ND_Index_Node_Find ND_Index_Node_Find_I +#define ND_Index_Open ND_Index_Open_I +#define ND_Index_Close ND_Index_Close_I +#define ND_Index_Flush ND_Index_Flush_I +#define ND_Index_Check ND_Index_Check_I +#define ND_Index_Convert ND_Index_Convert_I +#define ND_Index_Reorg ND_Index_Reorg_I +#define ND_Index_Traverse_V ND_Index_Traverse_VI +#define ND_Index_Traverse ND_Index_Traverse_I +#define ND_Index_Info_Print ND_Index_Info_Print_I +#define ND_Index_Value_Add ND_Index_Value_Add_I +#define ND_Index_Value_Remove ND_Index_Value_Remove_I +#define ND_Index_Value_Print ND_Index_Value_Print_I +#define ND_Index_Node_Add ND_Index_Node_Add_I +#define ND_Index_Node_Remove ND_Index_Node_Remove_I +#define ND_Index_Node_First_Get ND_Index_Node_First_Get_I +#define ND_Index_Node_Last_Get ND_Index_Node_Last_Get_I +#define ND_Index_Node_Next_Get ND_Index_Node_Next_Get_I +#define ND_Index_Node_Previous_Get ND_Index_Node_Previous_Get_I +#define ND_Index_Node_Find ND_Index_Node_Find_I #define ND_Node_Root_Get ND_Node_Root_Get_I @@ -389,7 +385,7 @@ typedef int NDT_Recursive_Offset; #define ND_Library_Open ND_Library_Open_C #define ND_Library_Close ND_Library_Close_C -#define ND_Library_Stderr_Set ND_Library_Stderr_Set_C +#define ND_Library_StdErr_Set ND_Library_Stderr_Set_C #define ND_DataStruct_Open ND_DataStruct_Open_C #define ND_DataStruct_Close ND_DataStruct_Close_C @@ -405,25 +401,25 @@ typedef int NDT_Recursive_Offset; #define ND_DataStruct_Value_Print ND_DataStruct_Value_Print_C #define ND_DataStruct_Value_Find ND_DataStruct_Value_Find_C -#define ND_Index_Open ND_Index_Open_C -#define ND_Index_Close ND_Index_Close_C -#define ND_Index_Flush ND_Index_Flush_C -#define ND_Index_Check ND_Index_Check_C -#define ND_Index_Convert ND_Index_Convert_C -#define ND_Index_Reorg ND_Index_Reorg_C -#define ND_Index_Traverse_V ND_Index_Traverse_VC -#define ND_Index_Traverse ND_Index_Traverse_C -#define ND_Index_Info_Print ND_Index_Info_Print_C -#define ND_Index_Value_Add ND_Index_Value_Add_C -#define ND_Index_Value_Remove ND_Index_Value_Remove_C -#define ND_Index_Value_Print ND_Index_Value_Print_C -#define ND_Index_Node_Add ND_Index_Node_Add_C -#define ND_Index_Node_Remove ND_Index_Node_Remove_C -#define ND_Index_Node_First_Get ND_Index_Node_First_Get_C -#define ND_Index_Node_Last_Get ND_Index_Node_Last_Get_C -#define ND_Index_Node_Next_Get ND_Index_Node_Next_Get_C -#define ND_Index_Node_Previous_Get ND_Index_Node_Previous_Get_C -#define ND_Index_Node_Find ND_Index_Node_Find_C +#define ND_Index_Open ND_Index_Open_C +#define ND_Index_Close ND_Index_Close_C +#define ND_Index_Flush ND_Index_Flush_C +#define ND_Index_Check ND_Index_Check_C +#define ND_Index_Convert ND_Index_Convert_C +#define ND_Index_Reorg ND_Index_Reorg_C +#define ND_Index_Traverse_V ND_Index_Traverse_VC +#define ND_Index_Traverse ND_Index_Traverse_C +#define ND_Index_Info_Print ND_Index_Info_Print_C +#define ND_Index_Value_Add ND_Index_Value_Add_C +#define ND_Index_Value_Remove ND_Index_Value_Remove_C +#define ND_Index_Value_Print ND_Index_Value_Print_C +#define ND_Index_Node_Add ND_Index_Node_Add_C +#define ND_Index_Node_Remove ND_Index_Node_Remove_C +#define ND_Index_Node_First_Get ND_Index_Node_First_Get_C +#define ND_Index_Node_Last_Get ND_Index_Node_Last_Get_C +#define ND_Index_Node_Next_Get ND_Index_Node_Next_Get_C +#define ND_Index_Node_Previous_Get ND_Index_Node_Previous_Get_C +#define ND_Index_Node_Find ND_Index_Node_Find_C #define ND_Node_Root_Get ND_Node_Root_Get_C @@ -472,8 +468,8 @@ NDD_DLL_API NDT_Status ND_Library_Close_C( void); /*------------------------------------------------------------------------------*/ /* Définition de la sortie standard des messages d'erreur de la librairie */ /*------------------------------------------------------------------------------*/ -NDD_DLL_API NDT_Status ND_Library_Stderr_Set_I( FILE *Out); -NDD_DLL_API NDT_Status ND_Library_Stderr_Set_C( FILE *Out); +NDD_DLL_API NDT_Status ND_Library_StdErr_Set_I( FILE *Out); +NDD_DLL_API NDT_Status ND_Library_StdErr_Set_C( FILE *Out); @@ -560,8 +556,8 @@ NDD_DLL_API NDT_Status ND_DataStruct_Convert_C( NDT_Root *, NDT_Index_Type *) /*------------------------------------------------------------------------------*/ NDD_DLL_API NDT_Status ND_DataStruct_Traverse_VI( NDT_Root *, NDT_Command Command, va_list); NDD_DLL_API NDT_Status ND_DataStruct_Traverse_VC( NDT_Root *, NDT_Command Command, va_list); -NDD_DLL_API NDT_Status ND_DataStruct_Traverse_I( NDT_Root *, NDT_Command Command, ...); -NDD_DLL_API NDT_Status ND_DataStruct_Traverse_C( NDT_Root *, NDT_Command Command, ...); +NDD_DLL_API NDT_Status ND_DataStruct_Traverse_I( NDT_Root *, NDT_Command Command, ...); +NDD_DLL_API NDT_Status ND_DataStruct_Traverse_C( NDT_Root *, NDT_Command Command, ...); @@ -606,8 +602,8 @@ NDD_DLL_API NDT_Status ND_DataStruct_Value_Remove_C( NDT_Root *Root, void *Va /* (I) Out : flux de sortie */ /*------------------------------------------------------------------------------*/ NDD_DLL_API NDT_Status ND_DataStruct_Value_Print_VI( FILE *, NDT_Root *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, va_list); -NDD_DLL_API NDT_Status ND_DataStruct_Value_Print_I( FILE *, NDT_Root *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); -NDD_DLL_API NDT_Status ND_DataStruct_Value_Print_C( FILE *, NDT_Root *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); +NDD_DLL_API NDT_Status ND_DataStruct_Value_Print_I( FILE *, NDT_Root *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); +NDD_DLL_API NDT_Status ND_DataStruct_Value_Print_C( FILE *, NDT_Root *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); @@ -622,8 +618,8 @@ NDD_DLL_API NDT_Status ND_DataStruct_Value_Print_C( FILE *, NDT_Root *, NDT_R NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_VI( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, va_list); NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_VC( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, va_list); -NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_I( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, ...); -NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_C( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, ...); +NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_I( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, ...); +NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_C( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, ...); @@ -710,8 +706,8 @@ NDD_DLL_API NDT_Status ND_Index_Reorg_C( NDT_Root *, NDT_Index_Id); /*------------------------------------------------------------------------------*/ NDD_DLL_API NDT_Status ND_Index_Traverse_VI( NDT_Root *, NDT_Index_Id, NDT_Command, va_list); NDD_DLL_API NDT_Status ND_Index_Traverse_VC( NDT_Root *, NDT_Index_Id, NDT_Command, va_list); -NDD_DLL_API NDT_Status ND_Index_Traverse_I( NDT_Root *, NDT_Index_Id, NDT_Command, ...); -NDD_DLL_API NDT_Status ND_Index_Traverse_C( NDT_Root *, NDT_Index_Id, NDT_Command, ...); +NDD_DLL_API NDT_Status ND_Index_Traverse_I( NDT_Root *, NDT_Index_Id, NDT_Command, ...); +NDD_DLL_API NDT_Status ND_Index_Traverse_C( NDT_Root *, NDT_Index_Id, NDT_Command, ...); @@ -758,8 +754,8 @@ NDD_DLL_API NDT_Status ND_Index_Value_Remove_C( NDT_Root *Root, NDT_Index_Id, /* (I) Out : flux de sortie */ /*------------------------------------------------------------------------------*/ NDD_DLL_API NDT_Status ND_Index_Value_Print_VI( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, va_list); -NDD_DLL_API NDT_Status ND_Index_Value_Print_I( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); -NDD_DLL_API NDT_Status ND_Index_Value_Print_C( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); +NDD_DLL_API NDT_Status ND_Index_Value_Print_I( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); +NDD_DLL_API NDT_Status ND_Index_Value_Print_C( FILE *, NDT_Root *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...); @@ -838,8 +834,8 @@ NDD_DLL_API NDT_Status ND_Index_Node_Previous_Get_C( NDT_Node **, NDT_Node *) /*------------------------------------------------------------------------------*/ NDD_DLL_API NDT_Status ND_Index_Node_Find_VI( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, va_list); NDD_DLL_API NDT_Status ND_Index_Node_Find_VC( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, va_list); -NDD_DLL_API NDT_Status ND_Index_Node_Find_I( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, ...); -NDD_DLL_API NDT_Status ND_Index_Node_Find_C( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, ...); +NDD_DLL_API NDT_Status ND_Index_Node_Find_I( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, ...); +NDD_DLL_API NDT_Status ND_Index_Node_Find_C( NDT_Node **, NDT_Root *, NDT_Index_Id, void *, ...); @@ -884,8 +880,8 @@ NDD_DLL_API NDT_Status ND_Value_Free_C( NDT_Root *, void *); /*------------------------------------------------------------------------------*/ NDD_DLL_API NDT_Status ND_Manager_Exec_VI( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); NDD_DLL_API NDT_Status ND_Manager_Exec_VC( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); -NDD_DLL_API NDT_Status ND_Manager_Exec_I( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, ...); -NDD_DLL_API NDT_Status ND_Manager_Exec_C( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, ...); +NDD_DLL_API NDT_Status ND_Manager_Exec_I( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, ...); +NDD_DLL_API NDT_Status ND_Manager_Exec_C( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, ...); diff --git a/lib/libnode.c b/lib/libnode.c index 86a6ddf..be33bb2 100644 --- a/lib/libnode.c +++ b/lib/libnode.c @@ -1,9 +1,9 @@ /*---------------------------------------------------------------------------------*/ /* $RCSfile: libnode.c,v $ */ /*---------------------------------------------------------------------------------*/ -/* $Revision: 2.9 $ */ +/* $Revision: 2.10 $ */ /* $Name: $ */ -/* $Date: 2004/06/17 22:28:04 $ */ +/* $Date: 2004/08/01 23:18:38 $ */ /* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ @@ -34,7 +34,7 @@ #include #ifdef _LIBVER_SUPPORT - VER_INFO_EXPORT (libnode,"$Revision: 2.9 $", "$Name: $",__FILE__,"$Author: agibert $") +VER_INFO_EXPORT( libnode, "$Revision: 2.10 $", "$Name: $", __FILE__, "$Author: agibert $") #endif @@ -63,7 +63,7 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT Command_Name = "NDD_CMD_MANAGER_VERSION"; - *Version_Name_Ptr = "$Revision: 2.9 $ $Name: $ $Date: 2004/06/17 22:28:04 $ $Author: agibert $"; + *Version_Name_Ptr = "$Revision: 2.10 $ $Name: $ $Date: 2004/08/01 23:18:38 $ $Author: agibert $"; return( NDS_OK); } @@ -71,10 +71,10 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT case NDD_CMD_INDEX_GET: { /* - NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); - NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); - NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); - void *Value_ptr = (void *)va_arg( Args, void *); + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); */ NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); @@ -87,21 +87,21 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT switch(Cmd) { /* - case NDT_CMD_SOME_USER_CMD: - { - *Reply_Index_Id_Ptr = 0; - *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD; - break; - } + case NDT_CMD_SOME_USER_CMD: + { + *Reply_Index_Id_Ptr = 0; + *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD; + break; + } - ... + ... */ default: { - *Reply_Index_Id_Ptr = Index_Id; - *Reply_Command_Ptr = Cmd; - break; + *Reply_Index_Id_Ptr = Index_Id; + *Reply_Command_Ptr = Cmd; + break; } } @@ -111,78 +111,355 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT case NDD_CMD_VALUE_ALLOC: { /* - void **Value_Ptr_Ptr = (void **)va_arg( Args, void **); - va_list user_args = (va_list)va_arg( Args, va_list); - user_type user_data = (user_type)va_arg( user_args, user_type); - ... = (...)va_arg( user_args, ...); + void **Value_Ptr_Ptr = (void **)va_arg( Args, void **); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); */ Command_Name = "NDD_CMD_VALUE_ALLOC"; /* - if( ( *Value_Ptr_Ptr = (void *)malloc( sizeof(void))) == NULL) - { - return(NDS_ERRMEM); - } - else - { - ... + if( ( *Value_Ptr_Ptr = (void *)malloc( sizeof(void))) == NULL) + { + return(NDS_ERRMEM); + } + else + { + ... - return( NDS_OK); - } + return( NDS_OK); + } */ } case NDD_CMD_VALUE_FREE: { /* - void *Value_Ptr = (void *)va_arg( Args, void *); - va_list user_args = (va_list)va_arg( Args, va_list); - user_type user_data = (user_type)va_arg( user_args, user_type); - ... = (...)va_arg( user_args, ...); + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); */ Command_Name = "NDD_CMD_VALUE_FREE"; /* - free( Value_Ptr); + free( Value_Ptr); - return( NDS_OK); + return( NDS_OK); */ } case NDD_CMD_VALUE_COMP: { /* - void *Value1_Ptr = (void *)va_arg( Args, void *); - void *Value2_Ptr = (void *)va_arg( Args, void *); - va_list user_args = (va_list)va_arg( Args, va_list); - user_type user_data = (user_type)va_arg( user_args, user_type); - ... = (...)va_arg( user_args, ...); + void *Value1_Ptr = (void *)va_arg( Args, void *); + void *Value2_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); */ Command_Name = "NDD_CMD_VALUE_COMP"; /* + switch( Index_Id) + { + case 0: + { + int rc; + + + rc = strcmp( Value1_Ptr->..., Value2_Ptr->...); + + if( rc < 0) + { + return(NDS_LOWER); + } + else + { + if( rc > 0) + { + return(NDS_GREATER); + } + else + { + return(NDS_EQUAL); + } + } + } + + case 1: + { + int val1 = atoi(Value1_Ptr->...); + int val2 = atoi(Value2_Ptr->...); + + + if( val1 < val2) + { + return(NDS_LOWER); + } + else + { + if( val1 > val2) + { + return(NDS_GREATER); + } + else + { + return(NDS_EQUAL); + } + } + } + + case 2: + { + ... + } + + default: + { + printf( "Unknown COMP idx (%d) !\n", Index_Id); + return( NDS_KO); + } + } + + return( NDS_OK); + */ + } + + case NDD_CMD_VALUE_ADD: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ADD"; + + /* + return( NDS_OK); + */ + } + + case NDD_CMD_VALUE_REMOVE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_REMOVE"; + /* + return( NDS_OK); + */ + } + + case NDD_CMD_VALUE_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + + Command_Name = "NDD_CMD_VALUE_PRINT"; + + /* + fprintf( Out, "...\n", Value_Ptr->..., ...); + + return( NDS_OK); + */ + } + + case NDD_CMD_INFO_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + + Command_Name = "NDD_CMD_INFO_PRINT"; + + /* + return( NDS_OK); + */ + } + + case NDD_CMD_USER_TRAVERSE: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + + Command_Name = "NDD_CMD_USER_TRAVERSE"; + + /* + return( NDS_OK); + */ + } + + default: + { + printf( "ND_Default_Manager() called with an undefined command %d\n", Command); + return(NDS_ERRAPI); + } + } + + printf( "ND_Default_Manager() called with command %d (%s)\n", Command, Command_Name); + return(NDS_OK); +} + + + + + + + +/*------------------------------------------------------------------------------*/ +/* OpenStruct Manager */ +/*------------------------------------------------------------------------------*/ + +NDT_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) +{ + NDT_Command_Name Command_Name; + + + switch( Command) + { + case NDD_CMD_MANAGER_VERSION: + { + NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); + + + Command_Name = "NDD_CMD_MANAGER_VERSION"; + + *Version_Name_Ptr = "$Revision: 2.10 $ $Name: $ $Date: 2004/08/01 23:18:38 $ $Author: agibert $"; + + return( NDS_OK); + } + + case NDD_CMD_INDEX_GET: + { + /* + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + */ + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + void *Value_ptr = (void *)va_arg( Args, void *); + + + Command_Name = "NDD_CMD_INDEX_GET"; + + switch(Cmd) + { + default: + { + *Reply_Index_Id_Ptr = Index_Id; + *Reply_Command_Ptr = Cmd; + break; + } + } + + return( NDS_OK); + } + + case NDD_CMD_VALUE_ALLOC: + { + /* + void **Value_Ptr_Ptr = (void **)va_arg( Args, void **); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_ALLOC"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_FREE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_FREE"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_COMP: + { + /* + void *Value1_Ptr = (void *)va_arg( Args, void *); + void *Value2_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + void *Value1_Ptr = (void *)va_arg( Args, void *); + void *Value2_Ptr = (void *)va_arg( Args, void *); + + + Command_Name = "NDD_CMD_VALUE_COMP"; + switch( Index_Id) { case 0: { - int rc; - - - rc = strcmp( Value1_Ptr->..., Value2_Ptr->...); - - if( rc < 0) + if( Value1_Ptr < Value2_Ptr) { return(NDS_LOWER); } else { - if( rc > 0) + if( Value1_Ptr > Value2_Ptr) { return(NDS_GREATER); } @@ -193,34 +470,6 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT } } - case 1: - { - int val1 = atoi(Value1_Ptr->...); - int val2 = atoi(Value2_Ptr->...); - - - if( val1 < val2) - { - return(NDS_LOWER); - } - else - { - if( val1 > val2) - { - return(NDS_GREATER); - } - else - { - return(NDS_EQUAL); - } - } - } - - case 2: - { - ... - } - default: { printf( "Unknown COMP idx (%d) !\n", Index_Id); @@ -229,120 +478,100 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT } return( NDS_OK); - */ } case NDD_CMD_VALUE_ADD: { /* - void *Value_Ptr = (void *)va_arg( Args, void *); - va_list user_args = (va_list)va_arg( Args, va_list); - user_type user_data = (user_type)va_arg( user_args, user_type); - ... = (...)va_arg( user_args, ...); + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); */ Command_Name = "NDD_CMD_VALUE_ADD"; - /* - return( NDS_OK); - */ + return( NDS_OK); } case NDD_CMD_VALUE_REMOVE: { /* - void *Value_Ptr = (void *)va_arg( Args, void *); - va_list user_args = (va_list)va_arg( Args, va_list); - user_type user_data = (user_type)va_arg( user_args, user_type); - ... = (...)va_arg( user_args, ...); + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); */ Command_Name = "NDD_CMD_VALUE_REMOVE"; - /* - return( NDS_OK); - */ + + return( NDS_OK); } case NDD_CMD_VALUE_PRINT: { /* - NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); - va_list lib_args = (va_list)va_arg( Args, va_list); - FILE *Out = (FILE *)va_arg( lib_args, FILE *); - NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); - NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); - NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); - va_list user_args = (va_list)va_arg( lib_args, va_list); - user_type user_data = (user_type)va_arg( user_args, user_type); - ... = (...)va_arg( user_args, ...); + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); - void *Value_Ptr = Node_Ptr->Value; + void *Value_Ptr = Node_Ptr->Value; */ Command_Name = "NDD_CMD_VALUE_PRINT"; - /* - fprintf( Out, "...\n", Value_Ptr->..., ...); - return( NDS_OK); - */ } case NDD_CMD_INFO_PRINT: { /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); va_list lib_args = (va_list)va_arg( Args, va_list); FILE *Out = (FILE *)va_arg( lib_args, FILE *); NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); NDT_Recursive_Offset Recursive_Offset = (NDT_Recursive_Offset)va_arg( lib_args, NDT_Recursive_Offset); - va_list user_args = (va_list)va_arg( lib_args, va_list); - user_type user_data = (user_type)va_arg( user_args, user_type); - ... = (...)va_arg( user_args, ...); void *Value_Ptr = Node_Ptr->Value; - */ Command_Name = "NDD_CMD_INFO_PRINT"; - /* - return( NDS_OK); - */ + return( ND_DataStruct_Info_Print_I( Out, (NDT_Root *)Value_Ptr, Recursive_Mode, --Recursive_Depth, ++Recursive_Offset)); } - case NDD_CMD_USER_TRAVERSE: - { - /* - NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); - va_list user_args = (va_list)va_arg( Args, va_list); - user_type user_data = (user_type)va_arg( user_args, user_type); - ... = (...)va_arg( user_args, ...); - - void *Value_Ptr = Node_Ptr->Value; - */ - - - Command_Name = "NDD_CMD_USER_TRAVERSE"; - - /* - return( NDS_OK); - */ - } - default: { - printf( "Default_Manager() called with an undefined command %d\n", Command); - return(NDS_ERRAPI); + printf( "OpenStruct_Manager() called with an undefined command %d\n", Command); + return( NDS_ERRAPI); } } - printf( "Default_Manager() called with command %d (%s)\n", Command, Command_Name); - return(NDS_OK); + printf( "OpenStruct_Manager() called with command %d (%s)\n", Command, Command_Name); + return( NDS_OK); } @@ -357,10 +586,6 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT /*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* FONCTIONS OPTIMISEES (ND_MODE = 1) */ -/*------------------------------------------------------------------------------*/ - @@ -369,9 +594,15 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT /* Initialisation du contexte de la librairie */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Library_Open_I( int Debug_Mode) +NDT_Status ND_Library_Open_I( int Debug_Mode) { - if( Debug_Mode == NDD_TRUE) ND_Library_Stderr_Set_I( stderr); + NDG_Base.Debug_Mode = Debug_Mode; + NDG_Base.Open_Status = NDD_TRUE; + + if( Debug_Mode == NDD_TRUE) + { + ND_Library_StdErr_Set_I( stderr); + } return( NDS_OK); } @@ -386,7 +617,31 @@ NDT_Status ND_Library_Open_I( int Debug_Mode) NDT_Status ND_Library_Open_C( int Debug_Mode) { - return ND_Library_Open_I( Debug_Mode); + NDT_Status status; + + + if( NDG_Base.Open_Status != NDD_FALSE) + { + sprintf( NDG_Base.Err_String, "Error ND_Library_Open_C: library is not closed"); + ND_Error_Print(); + + return( NDS_KO); + } + else + { + if( Debug_Mode == NDD_TRUE) + { + if( ( status = ND_DataStruct_Open_I( &(NDG_Base.OpenStruct_Ptr), 1, NDG_Base.OpenStruct_Index_Type, "ND_OpenStruct_Manager", ND_OpenStruct_Manager, NULL, NULL, NULL, NULL, 0, NULL)) != NDS_OK) + { + sprintf( NDG_Base.Err_String, "Error ND_Library_Open_C: can't open OpenStruct"); + ND_Error_Print(); + + return( NDS_KO); + } + } + } + + return( ND_Library_Open_I( Debug_Mode)); } @@ -397,26 +652,29 @@ NDT_Status ND_Library_Open_C( int Debug_Mode) /* Fermeture du contexte de la librairie */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Library_Close_I( void) +NDT_Status ND_Library_Close_I( void) { - struct Symbol * Symbol, * Next_Symbol; + NDT_Symbol *Symbol, *Next_Symbol; /* Désallocation de la table des symboles locale */ - Symbol = Symbol_Table; + Symbol = NDG_Base.Symbol_First_Ptr; while (Symbol) { - Next_Symbol = Symbol->Next; - free (Symbol->Name); - free (Symbol); - Symbol = Next_Symbol; + Next_Symbol = Symbol->Next; + free (Symbol->Name); + free (Symbol); + Symbol = Next_Symbol; } - Symbol_Table = NULL; + NDG_Base.Symbol_First_Ptr = (NDT_Symbol *)NULL; - return NDS_OK; + + NDG_Base.Open_Status = NDD_FALSE; + + return( NDS_OK); } @@ -429,7 +687,43 @@ NDT_Status ND_Library_Close_I( void) NDT_Status ND_Library_Close_C( void) { - return ND_Library_Close_I(); + NDT_Status status; + + + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Library_Close_C: library is not opened"); + ND_Error_Print(); + + return( NDS_KO); + } + + if( NDG_Base.Debug_Mode == NDD_TRUE) + { + if( NDG_Base.OpenStruct_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number > 0) + { + sprintf( NDG_Base.Err_String, "Error ND_Library_Open_C: Unclosed DataStruct:"); + ND_Error_Print(); + + if( ( status = ND_DataStruct_Info_Print_I( NDG_Base.Err_Stream, NDG_Base.OpenStruct_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK) + { + sprintf( NDG_Base.Err_String, "Error ND_Library_Open_C: can't print OpenStruct info"); + ND_Error_Print(); + + return( NDS_KO); + } + } + + if( ( status = ND_DataStruct_Close_I( NDG_Base.OpenStruct_Ptr)) != NDS_OK) + { + sprintf( NDG_Base.Err_String, "Error ND_Library_Open_C: can't close OpenStruct"); + ND_Error_Print(); + + return( NDS_KO); + } + } + + return( ND_Library_Close_I()); } @@ -442,10 +736,11 @@ NDT_Status ND_Library_Close_C( void) /* (I) Out : flux de sortie de l'affichage des messages d'erreur */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Library_Stderr_Set_I( FILE *Out) +NDT_Status ND_Library_StdErr_Set_I( FILE *Out) { - ND_stderr = Out; - return NDS_OK; + NDG_Base.Err_Stream = Out; + + return( NDS_OK); } @@ -458,9 +753,17 @@ NDT_Status ND_Library_Stderr_Set_I( FILE *Out) /* (I) Out : flux de sortie de l'affichage des messages d'erreur */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Library_Stderr_Set_C( FILE *Out) +NDT_Status ND_Library_StdErr_Set_C( FILE *Out) { - return ND_Library_Stderr_Set_I( Out); + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Library_StdErr_Set_C: library is not opened"); + ND_Error_Print(); + + return( NDS_KO); + } + + return( ND_Library_StdErr_Set_I( Out)); } @@ -484,17 +787,11 @@ NDT_Status ND_Index_Open_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_In NDT_Node *node_ptr; - if( ( Root_Ptr->Index_Open_Count == 0) && ( Index_Id != NDD_INDEX_PRIMARY)) - { - sprintf( ND_Error_Msg, "Error ND_Index_Open_I: fist opened index should be the primary"); - ND_Error_Print(); - return(NDS_ERRAPI); - } - if( ( status = ND_Index_Clear( Root_Ptr, Index_Id)) != NDS_OK) { - sprintf( ND_Error_Msg, "Error ND_Index_Open_I: Index cleaning error"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: Index cleaning error"); ND_Error_Print(); + return( NDS_KO); } @@ -506,8 +803,9 @@ NDT_Status ND_Index_Open_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_In { if( ( status = ND_Index_Node_First_Get_I( &node_ptr, Root_Ptr, NDD_INDEX_PRIMARY)) != NDS_OK) { - sprintf( ND_Error_Msg, "Error ND_Index_Open_I: can't get first primary index node"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: can't get first primary index node"); ND_Error_Print(); + return( NDS_KO); } @@ -515,15 +813,17 @@ NDT_Status ND_Index_Open_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_In { if( ( status = ND_Index_Value_Add_I( Root_Ptr, Index_Id, node_ptr->Value)) != NDS_OK) { - sprintf( ND_Error_Msg, "Error ND_Index_Open_I: can't add value"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: can't add value"); ND_Error_Print(); + return( NDS_KO); } if( ( status = ND_Index_Node_Next_Get_I( &node_ptr, node_ptr)) != NDS_OK) { - sprintf( ND_Error_Msg, "Error ND_Index_Open_I: can't get next node"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: can't get next node"); ND_Error_Print(); + return( NDS_KO); } } @@ -551,16 +851,34 @@ NDT_Status ND_Index_Open_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_I { if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Open_C: structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Open_C: structure root is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); + } + + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Open_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); } if( !ND_INDEX_STATUS_CLOSED_IS( Root_Ptr, Index_Id)) { - sprintf( ND_Error_Msg, "Error ND_Index_Open_C: index is not closed"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Open_C: index is not closed"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); + } + + if( ( Root_Ptr->Index_Open_Count == 0) && ( Index_Id != NDD_INDEX_PRIMARY)) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: fist opened index should be the primary"); + ND_Error_Print(); + + return( NDS_ERRAPI); } return( ND_Index_Open_I( Root_Ptr, Index_Id, Type)); @@ -582,52 +900,52 @@ NDT_Status ND_Index_Open_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_I /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Open_I( NDT_Root **Root_Ptr_Ptr, NDT_Index_Nb Index_Nb, NDT_Index_Type *Type_Ptr, NDT_Manager_Name Manager_Name, NDT_Manager *Manager_Ptr, - NDT_Allocator_Name Allocator_Name, NDT_Allocator *Allocator_Ptr, NDT_Desallocator_Name Desallocator_Name, NDT_Desallocator *Desallocator_Ptr, short Own_Value, void *Data) + NDT_Allocator_Name Allocator_Name, NDT_Allocator *Allocator_Ptr, NDT_Desallocator_Name Desallocator_Name, NDT_Desallocator *Desallocator_Ptr, short Own_Value, void *Data) { NDT_Status status; // const char *Real_Allocator, *Real_Desallocator; // Win32 - NDT_Manager_Name Real_Manager_Name; - NDT_Manager *Real_Manager_Ptr; + NDT_Manager_Name Real_Manager_Name; + NDT_Manager *Real_Manager_Ptr; NDT_Allocator_Name Real_Allocator_Name; NDT_Allocator *Real_Allocator_Ptr; - NDT_Desallocator_Name Real_Desallocator_Name; - NDT_Desallocator *Real_Desallocator_Ptr; + NDT_Desallocator_Name Real_Desallocator_Name; + NDT_Desallocator *Real_Desallocator_Ptr; /* Valeurs par défaut des fonctions d'allocation et de désallocation */ if( Manager_Ptr) - { - Real_Manager_Name = Manager_Name; - Real_Manager_Ptr = Manager_Ptr; - } - else - { - Real_Manager_Name = "ND_Default_Manager"; - Real_Manager_Ptr = ND_Default_Manager; - } + { + Real_Manager_Name = Manager_Name; + Real_Manager_Ptr = Manager_Ptr; + } + else + { + Real_Manager_Name = "ND_Default_Manager"; + Real_Manager_Ptr = ND_Default_Manager; + } if( Allocator_Ptr) - { - Real_Allocator_Name = Allocator_Name; - Real_Allocator_Ptr = Allocator_Ptr; - } - else - { - Real_Allocator_Name = "ND_Default_Allocator"; - Real_Allocator_Ptr = ND_Default_Allocator; - } + { + Real_Allocator_Name = Allocator_Name; + Real_Allocator_Ptr = Allocator_Ptr; + } + else + { + Real_Allocator_Name = "ND_Default_Allocator"; + Real_Allocator_Ptr = ND_Default_Allocator; + } if( Desallocator_Ptr) - { - Real_Desallocator_Name = Desallocator_Name; - Real_Desallocator_Ptr = Desallocator_Ptr; - } - else - { - Real_Desallocator_Name = "ND_Default_Desallocator"; - Real_Desallocator_Ptr = ND_Default_Desallocator; - } + { + Real_Desallocator_Name = Desallocator_Name; + Real_Desallocator_Ptr = Desallocator_Ptr; + } + else + { + Real_Desallocator_Name = "ND_Default_Desallocator"; + Real_Desallocator_Ptr = ND_Default_Desallocator; + } status = ND_Node_Root_Alloc( Root_Ptr_Ptr, Index_Nb, Type_Ptr, Real_Manager_Name, Real_Manager_Ptr, Real_Allocator_Name, Real_Allocator_Ptr, Real_Desallocator_Name, Real_Desallocator_Ptr, Own_Value, Data); @@ -652,9 +970,36 @@ NDT_Status ND_DataStruct_Open_I( NDT_Root **Root_Ptr_Ptr, NDT_Index_Nb Index_N /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Open_C( NDT_Root **Root_Ptr_Ptr, NDT_Index_Nb Index_Nb, NDT_Index_Type *Type_Ptr, NDT_Manager_Name Manager_Name, NDT_Manager *Manager_Ptr, - NDT_Allocator_Name Allocator_Name, NDT_Allocator *Allocator_Ptr, NDT_Desallocator_Name Desallocator_Name, NDT_Desallocator *Desallocator_Ptr, short Own_Value, void *Data_Ptr) + NDT_Allocator_Name Allocator_Name, NDT_Allocator *Allocator_Ptr, NDT_Desallocator_Name Desallocator_Name, NDT_Desallocator *Desallocator_Ptr, short Own_Value, void *Data_Ptr) { - return ND_DataStruct_Open_I( Root_Ptr_Ptr, Index_Nb, Type_Ptr, Manager_Name, Manager_Ptr, Allocator_Name, Allocator_Ptr, Desallocator_Name, Desallocator_Ptr, Own_Value, Data_Ptr); + NDT_Status status; + + + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Open_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + + if( ( status = ND_DataStruct_Open_I( Root_Ptr_Ptr, Index_Nb, Type_Ptr, Manager_Name, Manager_Ptr, Allocator_Name, Allocator_Ptr, Desallocator_Name, Desallocator_Ptr, Own_Value, Data_Ptr)) != NDS_OK) + { + return( status); + } + + if( ( NDG_Base.Debug_Mode == NDD_TRUE) && ( NDG_Base.Open_Status == NDD_TRUE)) + { + if( ( status = ND_DataStruct_Value_Add_I( NDG_Base.OpenStruct_Ptr, (void **)*Root_Ptr_Ptr)) != NDS_OK) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Open_C: can't add value in OpenStruct"); + ND_Error_Print(); + + return( NDS_KO); + } + } + + return( NDS_OK); } @@ -674,7 +1019,7 @@ NDT_Status ND_Index_Close_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) if( ( Root_Ptr->Index_Open_Count != 1) && ( Index_Id == NDD_INDEX_PRIMARY)) { - sprintf( ND_Error_Msg, "Error ND_Index_Close_I: the primary should be the last closed"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Close_I: the primary should be the last closed"); ND_Error_Print(); return(NDS_ERRAPI); } @@ -686,7 +1031,7 @@ NDT_Status ND_Index_Close_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) Root_Ptr->Index_Open_Count--; - return(NDS_OK); + return( NDS_OK); } @@ -701,18 +1046,28 @@ NDT_Status ND_Index_Close_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) NDT_Status ND_Index_Close_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Close_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Close_C: structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Close_C: structure root is null"); ND_Error_Print(); + return( NDS_ERRAPI); } if( !ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id)) { - sprintf( ND_Error_Msg, "Error ND_Index_Close_C: index is not opened"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Close_C: index is not opened"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } return( ND_Index_Close_I( Root_Ptr, Index_Id)); @@ -751,14 +1106,42 @@ NDT_Status ND_DataStruct_Close_I( NDT_Root *Root_Ptr) NDT_Status ND_DataStruct_Close_C( NDT_Root *Root_Ptr) { - if (!Root_Ptr) + NDT_Status status; + + + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf (ND_Error_Msg, "Error ND_DataStruct_Close : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Close_C: library is not open"); ND_Error_Print(); + return( NDS_ERRAPI); } - return( ND_DataStruct_Close_I( Root_Ptr)); + if (!Root_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Close_C: structure root is null"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + + if( ( status = ND_DataStruct_Close_I( Root_Ptr)) != NDS_OK) + { + return( status); + } + + if( NDG_Base.Debug_Mode == NDD_TRUE) + { + if( ( status = ND_DataStruct_Value_Remove_I( NDG_Base.OpenStruct_Ptr, (void *)Root_Ptr)) != NDS_OK) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Close_I: can't remove value from OpenStruct"); + ND_Error_Print(); + + return( NDS_KO); + } + } + + return( NDS_OK); } @@ -769,7 +1152,7 @@ NDT_Status ND_DataStruct_Close_C( NDT_Root *Root_Ptr) /* (O) Root: pointeur sur la racine de la structure de données à détruire */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Index_Flush_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) +NDT_Status ND_Index_Flush_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) { NDT_Status status; NDT_Node *Node_Ptr, *Next_Node_Ptr; @@ -817,14 +1200,23 @@ NDT_Status ND_Index_Flush_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) NDT_Status ND_Index_Flush_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Flush_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Close : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Flush_C: structure root is null"); ND_Error_Print(); + return(NDS_ERRAPI); } - return( ND_Index_Flush_I( Root_Ptr, Index_Id)); + return( ND_Index_Flush_I( Root_Ptr, Index_Id)); } @@ -864,10 +1256,19 @@ NDT_Status ND_DataStruct_Flush_I( NDT_Root *Root_Ptr) NDT_Status ND_DataStruct_Flush_C( NDT_Root *Root_Ptr) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Flush_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if (!Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Flush : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Flush_C: structure root is null"); ND_Error_Print(); + return( NDS_ERRAPI); } @@ -895,24 +1296,24 @@ NDT_Status ND_Index_Check_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int *Corrected_Nb_Ptr = 0; - if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id)) + if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id)) + { + if( ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id)) { - if( ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id)) - { - ND_List_Check( Root_Ptr, Index_Id, Detected_Nb_Ptr, Corrected_Nb_Ptr, Out); - } - else if( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id)) - { - ND_Tree_Check( Root_Ptr, Index_Id, Detected_Nb_Ptr, Corrected_Nb_Ptr, Out); - } - else - { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Check : unknown structure type (%d) in structure (%p:%d)\n", Root_Ptr->Index_Tab[Index_Id].Type, Root_Ptr, Index_Id); - ND_Error_Print(); + ND_List_Check( Root_Ptr, Index_Id, Detected_Nb_Ptr, Corrected_Nb_Ptr, Out); + } + else if( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id)) + { + ND_Tree_Check( Root_Ptr, Index_Id, Detected_Nb_Ptr, Corrected_Nb_Ptr, Out); + } + else + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Check_I: unknown structure type (%d) in structure (%p:%d)\n", Root_Ptr->Index_Tab[Index_Id].Type, Root_Ptr, Index_Id); + ND_Error_Print(); - (*Detected_Nb_Ptr)++; - return( NDS_OK); - } + (*Detected_Nb_Ptr)++; + return( NDS_OK); + } /* Affichage du résultat de la procédure de vérification */ @@ -924,7 +1325,7 @@ NDT_Status ND_Index_Check_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int { fprintf( Out, "%d/%d error(s) corrected in the node structure (%p:%d)\n", *Corrected_Nb_Ptr, *Detected_Nb_Ptr, Root_Ptr, Index_Id); } - } + } return( NDS_OK); } @@ -946,22 +1347,33 @@ NDT_Status ND_Index_Check_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int NDT_Status ND_Index_Check_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int *Nb_Detected_Ptr, int *Nb_Corrected_Ptr, FILE *Out) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Check_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Check : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Check_C: structure root is null"); ND_Error_Print(); + (*Nb_Detected_Ptr)++; + return(NDS_ERRAPI); } if( !Out) { - sprintf( ND_Error_Msg, "Error ND_Index_Check : the stream descriptor is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Check_C: the stream descriptor is null"); ND_Error_Print(); + return(NDS_ERRAPI); } - return ND_Index_Check_I( Root_Ptr, Index_Id, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out); + return( ND_Index_Check_I( Root_Ptr, Index_Id, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out)); } @@ -983,7 +1395,7 @@ NDT_Status ND_DataStruct_Check_I( NDT_Root *Root_Ptr, int *Error_Detected_Nb_ { NDT_Status status; NDT_Index_Id index_id; - int index_error_detected_nb, index_error_corrected_nb; + int index_error_detected_nb, index_error_corrected_nb; for( index_id = 0; index_id < Root_Ptr->Index_Nb; index_id++) @@ -993,7 +1405,7 @@ NDT_Status ND_DataStruct_Check_I( NDT_Root *Root_Ptr, int *Error_Detected_Nb_ *Error_Detected_Nb_Ptr = *Error_Detected_Nb_Ptr + index_error_detected_nb; *Error_Corrected_Nb_Ptr = *Error_Corrected_Nb_Ptr + index_error_corrected_nb; - } + } return( NDS_OK); } @@ -1015,22 +1427,31 @@ NDT_Status ND_DataStruct_Check_I( NDT_Root *Root_Ptr, int *Error_Detected_Nb_ NDT_Status ND_DataStruct_Check_C( NDT_Root *Root_Ptr, int *Nb_Detected_Ptr, int *Nb_Corrected_Ptr, FILE *Out) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Check_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Check : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Check_C: structure root is null"); ND_Error_Print(); (*Nb_Detected_Ptr)++; - return NDS_ERRAPI; + + return( NDS_ERRAPI); } if( !Out) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Check : the stream descriptor is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Check_C: the stream descriptor is null"); ND_Error_Print(); - return NDS_ERRAPI; + return( NDS_ERRAPI); } - return ND_DataStruct_Check_I( Root_Ptr, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out); + return( ND_DataStruct_Check_I( Root_Ptr, Nb_Detected_Ptr, Nb_Corrected_Ptr, Out)); } @@ -1049,91 +1470,91 @@ NDT_Status ND_Index_Convert_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT NDT_Status rc; - if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id)) + if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id)) + { + switch( Root_Ptr->Index_Tab[Index_Id].Type & NDD_INDEX_TYPE_MSK) { - switch( Root_Ptr->Index_Tab[Index_Id].Type & NDD_INDEX_TYPE_MSK) + case NDD_INDEX_TYPE_LIST: + { + + switch( Target_Type & ( NDD_INDEX_TYPE_MSK | NDD_INDEX_SUBTYPE_MSK)) { - case NDD_INDEX_TYPE_LIST: - { + case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED): + { + rc = ND_List_Sort( Root_Ptr, Index_Id); + if( ND_ERROR( rc)) return( rc); - switch( Target_Type & ( NDD_INDEX_TYPE_MSK | NDD_INDEX_SUBTYPE_MSK)) - { - case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED): - { - rc = ND_List_Sort( Root_Ptr, Index_Id); - if( ND_ERROR( rc)) return( rc); + Root_Ptr->Index_Tab[Index_Id].Type = Target_Type; - Root_Ptr->Index_Tab[Index_Id].Type = Target_Type; + return( rc); + } - return( rc); - } + case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO): + case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_LIFO): + { + Root_Ptr->Index_Tab[Index_Id].Type = Target_Type; - case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO): - case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_LIFO): - { - Root_Ptr->Index_Tab[Index_Id].Type = Target_Type; - - return( NDS_OK); - } + return( NDS_OK); + } - case( NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED): - case( NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_UNBALANCED): - { - rc = ND_List_Sort( Root_Ptr, Index_Id); - if( rc != NDS_OK) return( rc); + case( NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED): + case( NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_UNBALANCED): + { + rc = ND_List_Sort( Root_Ptr, Index_Id); + if( rc != NDS_OK) return( rc); - rc = ND_Tree_Make( Root_Ptr, Index_Id); - if( ND_ERROR( rc)) return( rc); + rc = ND_Tree_Make( Root_Ptr, Index_Id); + if( ND_ERROR( rc)) return( rc); - Root_Ptr->Index_Tab[Index_Id].Type = Target_Type; + Root_Ptr->Index_Tab[Index_Id].Type = Target_Type; - return( rc); - } + return( rc); + } - default: - { - return( NDS_KO); - } - } - - break; - } - - case NDD_INDEX_TYPE_TREE: - { - switch( Target_Type & ( NDD_INDEX_TYPE_MSK | NDD_INDEX_SUBTYPE_MSK)) - { - case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED): - case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO): - case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_LIFO): - { - - rc = ND_List_Make( Root_Ptr, Index_Id); - if( ND_ERROR( rc)) return( rc); - - Root_Ptr->Index_Tab[Index_Id].Type = Target_Type; - - return( rc); - } - - default: - { - return( NDS_KO); - } - } - - break; - } - - default: - { - sprintf (ND_Error_Msg, "Error ND_DataStruct_Reorg : unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type); - ND_Error_Print (); - return NDS_ERRAPI; - } + default: + { + return( NDS_KO); + } } + + break; + } + + case NDD_INDEX_TYPE_TREE: + { + switch( Target_Type & ( NDD_INDEX_TYPE_MSK | NDD_INDEX_SUBTYPE_MSK)) + { + case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED): + case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO): + case( NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_LIFO): + { + + rc = ND_List_Make( Root_Ptr, Index_Id); + if( ND_ERROR( rc)) return( rc); + + Root_Ptr->Index_Tab[Index_Id].Type = Target_Type; + + return( rc); + } + + default: + { + return( NDS_KO); + } + } + + break; + } + + default: + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Convert_I: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type); + ND_Error_Print (); + return NDS_ERRAPI; + } } + } return( NDS_OK); } @@ -1151,14 +1572,23 @@ NDT_Status ND_Index_Convert_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT NDT_Status ND_Index_Convert_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Index_Type Target_Type) { - if( !Root_Ptr) + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf( ND_Error_Msg, "Error ND_Index_Convert : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Convert_C: library is not open"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_Index_Convert_I( Root_Ptr, Index_Id, Target_Type); + if( !Root_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Convert_C: structure root is null"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + + return( ND_Index_Convert_I( Root_Ptr, Index_Id, Target_Type)); } @@ -1174,17 +1604,17 @@ NDT_Status ND_Index_Convert_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT NDT_Status ND_DataStruct_Convert_I( NDT_Root *Root_Ptr, NDT_Index_Type *Target_Type_Ptr) { - NDT_Status rc; - NDT_Index_Nb idx; + NDT_Status rc; + NDT_Index_Nb idx; - for( idx = 0; idx < Root_Ptr->Index_Nb; idx++) - { - rc = ND_Index_Convert_I( Root_Ptr, idx, Target_Type_Ptr[idx]); - if( ND_ERROR(rc)) return rc; - } + for( idx = 0; idx < Root_Ptr->Index_Nb; idx++) + { + rc = ND_Index_Convert_I( Root_Ptr, idx, Target_Type_Ptr[idx]); + if( ND_ERROR(rc)) return rc; + } - return(NDS_OK); + return( NDS_OK); } @@ -1200,21 +1630,31 @@ NDT_Status ND_DataStruct_Convert_I( NDT_Root *Root_Ptr, NDT_Index_Type *Targe NDT_Status ND_DataStruct_Convert_C( NDT_Root *Root_Ptr, NDT_Index_Type *Target_Type_Ptr) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Convert_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Convert : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Convert_C: structure root is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } if( !Target_Type_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Convert : target type ptr is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Convert_C: target type ptr is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_DataStruct_Convert_I( Root_Ptr, Target_Type_Ptr); + return( ND_DataStruct_Convert_I( Root_Ptr, Target_Type_Ptr)); } @@ -1234,35 +1674,36 @@ NDT_Status ND_Index_Reorg_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) NDT_Status status; - if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id)) + if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, Index_Id)) + { + if( ( status = ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id))) { - if( ( status = ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id))) + if ( !ND_INDEX_SUBTYPE_SORTED_IS( Root_Ptr, Index_Id)) + { + if( ( status = ND_List_Sort( Root_Ptr, Index_Id)) != NDS_OK) { - if ( !ND_INDEX_SUBTYPE_SORTED_IS( Root_Ptr, Index_Id)) - { - if( ( status = ND_List_Sort( Root_Ptr, Index_Id)) != NDS_OK) - { - return( status); - } - } - } - else - { - if( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id)) - { - if( ( status = ND_Tree_Equalize( Root_Ptr, Index_Id)) != NDS_OK) - { - return( status); - } - } - else - { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Reorg : unknown structure type (%d) in structure (%p:%d)\n", Root_Ptr->Index_Tab[Index_Id].Type, Root_Ptr, Index_Id); - ND_Error_Print(); - return(NDS_ERRAPI); - } + return( status); } + } } + else + { + if( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id)) + { + if( ( status = ND_Tree_Equalize( Root_Ptr, Index_Id)) != NDS_OK) + { + return( status); + } + } + else + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Reorg_C: unknown structure type (%d) in structure (%p:%d)\n", Root_Ptr->Index_Tab[Index_Id].Type, Root_Ptr, Index_Id); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + } + } return( NDS_OK); } @@ -1281,14 +1722,23 @@ NDT_Status ND_Index_Reorg_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) NDT_Status ND_Index_Reorg_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) { - if( !Root_Ptr) + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Reorg : structure root is null"); - ND_Error_Print (); - return NDS_ERRAPI; + sprintf( NDG_Base.Err_String, "Error ND_Index_Reorg_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); } - return ND_Index_Reorg_I( Root_Ptr, Index_Id); + if( !Root_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Reorg_C: structure root is null"); + ND_Error_Print (); + + return( NDS_ERRAPI); + } + + return( ND_Index_Reorg_I( Root_Ptr, Index_Id)); } @@ -1311,7 +1761,7 @@ NDT_Status ND_DataStruct_Reorg_I( NDT_Root *Root_Ptr) for( index_id = 0; index_id < Root_Ptr->Index_Nb; index_id++) { - status = ND_Index_Reorg_I( Root_Ptr, index_id); + status = ND_Index_Reorg_I( Root_Ptr, index_id); if( ND_ERROR( status)) return status; } @@ -1332,14 +1782,23 @@ NDT_Status ND_DataStruct_Reorg_I( NDT_Root *Root_Ptr) NDT_Status ND_DataStruct_Reorg_C( NDT_Root *Root_Ptr) { - if( !Root_Ptr) + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Reorg : structure root is null"); - ND_Error_Print (); - return NDS_ERRAPI; + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Reorg_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); } - return ND_DataStruct_Reorg_I( Root_Ptr); + if( !Root_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Reorg_C: structure root is null"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + + return( ND_DataStruct_Reorg_I( Root_Ptr)); } @@ -1368,14 +1827,14 @@ NDT_Status ND_Index_Traverse_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND Next_Node_Ptr = NULL; ND_Index_Node_Next_Get_I( &Next_Node_Ptr, Node_Ptr); - switch (Command) + switch (Command) { case NDD_CMD_VALUE_REMOVE: case NDD_CMD_VALUE_FREE: - { + { - rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Node_Ptr->Value, Args); - if (ND_ERROR( rc)) return rc; + rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Node_Ptr->Value, Args); + if (ND_ERROR( rc)) return rc; rc = ND_Index_Node_Remove_I( Node_Ptr); if( ND_ERROR( rc)) return rc; @@ -1383,22 +1842,22 @@ NDT_Status ND_Index_Traverse_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND rc = ND_Node_Free( Root_Ptr, Node_Ptr); if (ND_ERROR(rc)) return rc; - break; - } + break; + } default: - { - rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Next_Node_Ptr, Args); - if (ND_ERROR( rc)) return rc; + { + rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Next_Node_Ptr, Args); + if (ND_ERROR( rc)) return rc; break; - } + } } Node_Ptr = Next_Node_Ptr; } - return NDS_OK; + return( NDS_OK); } @@ -1416,14 +1875,23 @@ NDT_Status ND_Index_Traverse_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND NDT_Status ND_Index_Traverse_VC( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Command Command, va_list Args) { - if( !Root_Ptr) + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Traverse_VC : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Traverse_VC: library is not open"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_Index_Traverse_VI( Root_Ptr, Index_Id, Command, Args); + if( !Root_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_VC: structure root is null"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + + return( ND_Index_Traverse_VI( Root_Ptr, Index_Id, Command, Args)); } @@ -1450,7 +1918,7 @@ NDT_Status ND_Index_Traverse_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT ND_Index_Node_First_Get_I( &Node_Ptr, Root_Ptr, Index_Id); - status = NDS_OK; + status = NDS_OK; while( Node_Ptr) { @@ -1507,24 +1975,33 @@ NDT_Status ND_Index_Traverse_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT NDT_Status ND_Index_Traverse_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Command Command, ...) { - NDT_Status status; - va_list args; + NDT_Status status; + va_list args; - va_start( args, Command); + va_start( args, Command); + + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Traverse_C : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_C: structure root is null"); ND_Error_Print(); + return( NDS_ERRAPI); } status = ND_Index_Traverse_VI( Root_Ptr, Index_Id, Command, args); - va_end( args); + va_end( args); - return( status); + return( status); } @@ -1547,10 +2024,10 @@ NDT_Status ND_DataStruct_Traverse_VI( NDT_Root *Root_Ptr, NDT_Command Command, NDT_Command new_cmd; - status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_INDEX_GET, &new_index, &new_cmd, Command, NULL); + status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_PRIMARY, NULL, NDD_CMD_INDEX_GET, &new_index, &new_cmd, Command, NULL); if( ND_ERROR(status)) return( status); - return( ND_Index_Traverse_VI( Root_Ptr, (NDT_Index_Id)(( new_index == NDD_INDEX_UNKNOWN) ? NDD_INDEX_PRIMARY : new_index), new_cmd, Args)); + return( ND_Index_Traverse_VI( Root_Ptr, new_index, new_cmd, Args)); } @@ -1568,14 +2045,22 @@ NDT_Status ND_DataStruct_Traverse_VI( NDT_Root *Root_Ptr, NDT_Command Command, NDT_Status ND_DataStruct_Traverse_VC( NDT_Root *Root_Ptr, NDT_Command Command, va_list Args) { - if( !Root_Ptr) + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Traverse_VC : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_VC: library is not open"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_DataStruct_Traverse_VI( Root_Ptr, Command, Args); + if( !Root_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_VC: structure root is null"); + ND_Error_Print(); + return( NDS_ERRAPI); + } + + return( ND_DataStruct_Traverse_VI( Root_Ptr, Command, Args)); } @@ -1594,21 +2079,21 @@ NDT_Status ND_DataStruct_Traverse_VC( NDT_Root *Root_Ptr, NDT_Command Command NDT_Status ND_DataStruct_Traverse_I( NDT_Root *Root_Ptr, NDT_Command Command, ...) { NDT_Status status; - va_list args; + va_list args; NDT_Index_Id new_index; NDT_Command new_cmd; - va_start( args, Command); + va_start( args, Command); - status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_INDEX_GET, &new_index, &new_cmd, Command, NULL); + status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_PRIMARY, NULL, NDD_CMD_INDEX_GET, &new_index, &new_cmd, Command, NULL); if( ND_ERROR( status)) return( status); - status = ND_Index_Traverse_VI( Root_Ptr, (NDT_Index_Id)(( new_index == NDD_INDEX_UNKNOWN) ? NDD_INDEX_PRIMARY : new_index), new_cmd, args); + status = ND_Index_Traverse_VI( Root_Ptr, new_index, new_cmd, args); - va_end( args); + va_end( args); - return( status); + return( status); } @@ -1626,24 +2111,33 @@ NDT_Status ND_DataStruct_Traverse_I( NDT_Root *Root_Ptr, NDT_Command Command, NDT_Status ND_DataStruct_Traverse_C( NDT_Root *Root_Ptr, NDT_Command Command, ...) { - NDT_Status status; - va_list args; + NDT_Status status; + va_list args; - va_start( args, Command); + va_start( args, Command); + + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Taverse_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Traverse_C : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Traverse_C: structure root is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } status = ND_DataStruct_Traverse_VI( Root_Ptr, Command, args); - va_end( args); + va_end( args); - return( status); + return( status); } @@ -1663,27 +2157,27 @@ NDT_Status ND_Index_Info_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_Id char offset[255]; - if( ND_RECURSIVE_PARENT_IS( Recursive_Mode)) - { - memset( offset, ' ', Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET); - offset[Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET] = '\0'; + if( ND_RECURSIVE_PARENT_IS( Recursive_Mode)) + { + memset( offset, ' ', Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET); + offset[Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET] = '\0'; - printf( "%s Index Id: (%d)\tType: (%#06x) [%s:%s:%s]\tNode Nb: (%d)\tHead: (%s%p)\tTail: (%s%p)\n%s Min Depth: (%d)\tMax Depth: (%d)\tMax Dif: (%d)\tNb Equ: (%d)\tSave: (%s%p)\n\n", - offset, Index_Id, Root_Ptr->Index_Tab[Index_Id].Type, ND_INDEX_STATUS_ASCII_GET( Root_Ptr, Index_Id), ND_INDEX_TYPE_ASCII_GET( Root_Ptr, Index_Id), ND_INDEX_SUBTYPE_ASCII_GET( Root_Ptr, Index_Id), - Root_Ptr->Index_Tab[Index_Id].Node_Number, - NDD_PRINTF_PTR_PREFIX, Root_Ptr->Index_Tab[Index_Id].Head, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Index_Tab[Index_Id].Tail, - offset, Root_Ptr->Index_Tab[Index_Id].Min_Depth, Root_Ptr->Index_Tab[Index_Id].Max_Depth, Root_Ptr->Index_Tab[Index_Id].Max_Dif, Root_Ptr->Index_Tab[Index_Id].Nb_Equ, - NDD_PRINTF_PTR_PREFIX, Root_Ptr->Index_Tab[Index_Id].Save); - } + printf( "%s Index Id: (%d)\tType: (%#06x) [%s:%s:%s]\tNode Nb: (%d)\tHead: (%s%p)\tTail: (%s%p)\n%s Min Depth: (%d)\tMax Depth: (%d)\tMax Dif: (%d)\tNb Equ: (%d)\tSave: (%s%p)\n\n", + offset, Index_Id, Root_Ptr->Index_Tab[Index_Id].Type, ND_INDEX_STATUS_ASCII_GET( Root_Ptr, Index_Id), ND_INDEX_TYPE_ASCII_GET( Root_Ptr, Index_Id), ND_INDEX_SUBTYPE_ASCII_GET( Root_Ptr, Index_Id), + Root_Ptr->Index_Tab[Index_Id].Node_Number, + NDD_PRINTF_PTR_PREFIX, Root_Ptr->Index_Tab[Index_Id].Head, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Index_Tab[Index_Id].Tail, + offset, Root_Ptr->Index_Tab[Index_Id].Min_Depth, Root_Ptr->Index_Tab[Index_Id].Max_Depth, Root_Ptr->Index_Tab[Index_Id].Max_Dif, Root_Ptr->Index_Tab[Index_Id].Nb_Equ, + NDD_PRINTF_PTR_PREFIX, Root_Ptr->Index_Tab[Index_Id].Save); + } - if( ND_RECURSIVE_CHILD_IS(Recursive_Mode)) - { - status = ND_Index_Traverse_I( Root_Ptr, Index_Id, NDD_CMD_INFO_PRINT, Out, NDD_RECURSIVE_MODE_PARENT_CHILD, Recursive_Depth, Recursive_Offset); - } - else - { - status = NDS_OK; - } + if( ND_RECURSIVE_CHILD_IS(Recursive_Mode)) + { + status = ND_Index_Traverse_I( Root_Ptr, Index_Id, NDD_CMD_INFO_PRINT, Out, NDD_RECURSIVE_MODE_PARENT_CHILD, Recursive_Depth, Recursive_Offset); + } + else + { + status = NDS_OK; + } return( status); } @@ -1701,18 +2195,28 @@ NDT_Status ND_Index_Info_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_Id NDT_Status ND_Index_Info_Print_C( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Info_Print_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Info_Print : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Info_Print_C: structure root is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } if( !Out) { - sprintf( ND_Error_Msg, "Error ND_Index_Info_Print : the stream descriptor is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Info_Print_C: the stream descriptor is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } return( ND_Index_Info_Print_I( Out, Root_Ptr, Index_Id, Recursive_Mode, Recursive_Depth, Recursive_Offset)); @@ -1737,34 +2241,34 @@ NDT_Status ND_DataStruct_Info_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Recu char offset[255]; - if( ND_RECURSIVE_PARENT_IS( Recursive_Mode)) - { - memset( offset, ' ', Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET); - offset[Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET] = '\0'; + if( ND_RECURSIVE_PARENT_IS( Recursive_Mode)) + { + memset( offset, ' ', Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET); + offset[Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET] = '\0'; - status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_MANAGER_VERSION, &version_name); - if( ND_ERROR( status)) return( status); + status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_MANAGER_VERSION, &version_name); + if( ND_ERROR( status)) return( status); - printf( "%sRoot: (%s%p)\tIndex Nb: (%d)\tIndex Open Count: (%d)\tManager: (%s%p) [%s]\n%sAllocator: (%s%p) [%s]\tDesallocator: (%s%p) [%s]\tUser: (%s%p)\n%sManager Version: [%s]\n\n", - offset, NDD_PRINTF_PTR_PREFIX, Root_Ptr, Root_Ptr->Index_Nb, Root_Ptr->Index_Open_Count, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Manager_Ptr, Root_Ptr->Manager_Name, + printf( "%sRoot: (%s%p)\tIndex Nb: (%d)\tIndex Open Count: (%d)\tManager: (%s%p) [%s]\n%sAllocator: (%s%p) [%s]\tDesallocator: (%s%p) [%s]\tUser: (%s%p)\n%sManager Version: [%s]\n\n", + offset, NDD_PRINTF_PTR_PREFIX, Root_Ptr, Root_Ptr->Index_Nb, Root_Ptr->Index_Open_Count, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Manager_Ptr, Root_Ptr->Manager_Name, offset, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Allocator_Ptr, Root_Ptr->Allocator_Name, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Desallocator_Ptr, Root_Ptr->Desallocator_Name, NDD_PRINTF_PTR_PREFIX, Root_Ptr->User, - offset, version_name); + offset, version_name); + } + + if( ND_RECURSIVE_CHILD_IS( Recursive_Mode)) + { + for( idx = NDD_INDEX_PRIMARY; idx < Root_Ptr->Index_Nb; idx++) + { + status = ND_Index_Info_Print_I( Out, Root_Ptr, idx, NDD_RECURSIVE_MODE_PARENT, 0, Recursive_Offset); + if( ND_ERROR( status)) return( status); } - if( ND_RECURSIVE_CHILD_IS( Recursive_Mode)) - { - for( idx = NDD_INDEX_PRIMARY; idx < Root_Ptr->Index_Nb; idx++) - { - status = ND_Index_Info_Print_I( Out, Root_Ptr, idx, NDD_RECURSIVE_MODE_PARENT, 0, Recursive_Offset); - if( ND_ERROR( status)) return( status); - } - - return( ND_Index_Info_Print_I( Out, Root_Ptr, NDD_INDEX_PRIMARY, NDD_RECURSIVE_MODE_CHILD, Recursive_Depth, Recursive_Offset)); - } - else - { - return( NDS_OK); - } + return( ND_Index_Info_Print_I( Out, Root_Ptr, NDD_INDEX_PRIMARY, NDD_RECURSIVE_MODE_CHILD, Recursive_Depth, Recursive_Offset)); + } + else + { + return( NDS_OK); + } } @@ -1780,18 +2284,27 @@ NDT_Status ND_DataStruct_Info_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Recu NDT_Status ND_DataStruct_Info_Print_C( FILE *Out, NDT_Root *Root_Ptr, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Info_Print_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf (ND_Error_Msg, "Error ND_DataStruct_Info_Print : structure root is null"); + sprintf (NDG_Base.Err_String, "Error ND_DataStruct_Info_Print_C: structure root is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } if( !Out) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Info_Print : the stream descriptor is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Info_Print_C: the stream descriptor is null"); ND_Error_Print(); - return(NDS_ERRAPI); + return( NDS_ERRAPI); } return( ND_DataStruct_Info_Print_I( Out, Root_Ptr, Recursive_Mode, Recursive_Depth, Recursive_Offset)); @@ -1825,7 +2338,7 @@ NDT_Status ND_Index_Value_Add_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, v } else { - sprintf( ND_Error_Msg, "Error ND_Index_Value_Add : unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type); + sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Add_I: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type); ND_Error_Print(); return( NDS_ERRAPI); } @@ -1846,21 +2359,31 @@ NDT_Status ND_Index_Value_Add_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, v NDT_Status ND_Index_Value_Add_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void *Value_Ptr) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Add_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Value_Add : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Add_C: structure root is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } if( !Value_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Value_Add : the value to add is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Add_C: the value to add is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_Index_Value_Add_I( Root_Ptr, Index_Id, Value_Ptr); + return( ND_Index_Value_Add_I( Root_Ptr, Index_Id, Value_Ptr)); } @@ -1884,7 +2407,7 @@ NDT_Status ND_DataStruct_Value_Add_I( NDT_Root *Root_Ptr, void *Value_Ptr) { if( ND_INDEX_STATUS_OPENED_IS( Root_Ptr, index_id)) { - status = ND_Index_Value_Add( Root_Ptr, index_id, Value_Ptr); + status = ND_Index_Value_Add_I( Root_Ptr, index_id, Value_Ptr); if( ND_ERROR( status)) return( status); } } @@ -1905,21 +2428,31 @@ NDT_Status ND_DataStruct_Value_Add_I( NDT_Root *Root_Ptr, void *Value_Ptr) NDT_Status ND_DataStruct_Value_Add_C( NDT_Root *Root_Ptr, void *Value_Ptr) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Add_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Value_Add : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Add_C: structure root is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } if( !Value_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DatatStruct_Value_Add : the value to add is null"); + sprintf( NDG_Base.Err_String, "Error ND_DatatStruct_Value_Add_C: the value to add is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_DataStruct_Value_Add_I( Root_Ptr, Value_Ptr); + return( ND_DataStruct_Value_Add_I( Root_Ptr, Value_Ptr)); } @@ -1978,21 +2511,31 @@ NDT_Status ND_Index_Value_Remove_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id NDT_Status ND_Index_Value_Remove_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void *Value_Ptr) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Remove_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Value_Remove : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Remove_C: structure root is null"); ND_Error_Print(); - return NDS_ERRAPI; + + return( NDS_ERRAPI); } if( !Value_Ptr) { - sprintf (ND_Error_Msg, "Error ND_Index_Value_Remove : the value is null"); + sprintf (NDG_Base.Err_String, "Error ND_Index_Value_Remove_C: the value is null"); ND_Error_Print (); - return NDS_ERRAPI; + + return( NDS_ERRAPI); } - return ND_Index_Value_Remove_I( Root_Ptr, Index_Id, Value_Ptr); + return( ND_Index_Value_Remove_I( Root_Ptr, Index_Id, Value_Ptr)); } @@ -2039,21 +2582,31 @@ NDT_Status ND_DataStruct_Value_Remove_I( NDT_Root *Root_Ptr, void *Value_Ptr) NDT_Status ND_DataStruct_Value_Remove_C( NDT_Root *Root_Ptr, void *Value_Ptr) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Remove_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Value_Remove : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Remove_C: structure root is null"); ND_Error_Print(); - return NDS_ERRAPI; + + return( NDS_ERRAPI); } if( !Value_Ptr) { - sprintf (ND_Error_Msg, "Error ND_DataStruct_Value_Remove : the value is null"); + sprintf (NDG_Base.Err_String, "Error ND_DataStruct_Value_Remove_C: the value is null"); ND_Error_Print (); - return NDS_ERRAPI; + + return( NDS_ERRAPI); } - return ND_DataStruct_Value_Remove_I( Root_Ptr, Value_Ptr); + return( ND_DataStruct_Value_Remove_I( Root_Ptr, Value_Ptr)); } @@ -2068,12 +2621,12 @@ NDT_Status ND_DataStruct_Value_Remove_C( NDT_Root *Root_Ptr, void *Value_Ptr) /*------------------------------------------------------------------------------*/ NDT_Status ND_Index_Value_Print_VI( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset, va_list Args) { - NDT_Status status; + NDT_Status status; - status = ND_Index_Traverse_I( Root_Ptr, Index_Id, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, Args); + status = ND_Index_Traverse_I( Root_Ptr, Index_Id, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, Args); - return( status); + return( status); } @@ -2088,17 +2641,17 @@ NDT_Status ND_Index_Value_Print_VI( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_I /*------------------------------------------------------------------------------*/ NDT_Status ND_Index_Value_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset, ...) { - NDT_Status status; - va_list user_args; + NDT_Status status; + va_list user_args; - va_start( user_args, Recursive_Offset); + va_start( user_args, Recursive_Offset); - status = ND_Index_Traverse_I( Root_Ptr, Index_Id, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args); + status = ND_Index_Traverse_I( Root_Ptr, Index_Id, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args); - va_end( user_args); + va_end( user_args); - return( status); + return( status); } @@ -2120,18 +2673,28 @@ NDT_Status ND_Index_Value_Print_C( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_I va_start( user_args, Recursive_Offset); + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Print_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Value_Print : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Print_C: structure root is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } if( !Out) { - sprintf( ND_Error_Msg, "Error ND_Index_Value_Print : the stream descriptor is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Value_Print_C: the stream descriptor is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } status = ND_Index_Value_Print_VI( Out, Root_Ptr, Index_Id, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args); @@ -2153,11 +2716,11 @@ NDT_Status ND_Index_Value_Print_C( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_I /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Value_Print_VI( FILE *Out, NDT_Root *Root_Ptr, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset, va_list User_Args) { - NDT_Status status; + NDT_Status status; - status = ND_DataStruct_Traverse_I( Root_Ptr, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, User_Args); + status = ND_DataStruct_Traverse_I( Root_Ptr, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, User_Args); - return( status); + return( status); } @@ -2172,17 +2735,17 @@ NDT_Status ND_DataStruct_Value_Print_VI( FILE *Out, NDT_Root *Root_Ptr, NDT_Re /*------------------------------------------------------------------------------*/ NDT_Status ND_DataStruct_Value_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset, ...) { - NDT_Status status; - va_list user_args; + NDT_Status status; + va_list user_args; - va_start( user_args, Recursive_Offset); + va_start( user_args, Recursive_Offset); - status = ND_DataStruct_Traverse_I( Root_Ptr, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args); + status = ND_DataStruct_Traverse_I( Root_Ptr, NDD_CMD_VALUE_PRINT, Out, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args); - va_end( user_args); + va_end( user_args); - return( status); + return( status); } @@ -2204,17 +2767,27 @@ NDT_Status ND_DataStruct_Value_Print_C( FILE *Out, NDT_Root *Root_Ptr, NDT_Re va_start( user_args, Recursive_Offset); + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Print_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Value_Print : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Print_C: structure root is null"); ND_Error_Print(); + return(NDS_ERRAPI); } if( !Out) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Value_Print : the stream descriptor is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Print_C: the stream descriptor is null"); ND_Error_Print(); + return(NDS_ERRAPI); } @@ -2242,7 +2815,7 @@ NDT_Status ND_Index_Node_Add_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND else if( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id)) return ND_Tree_Node_Add( Root_Ptr, Index_Id, Node_Ptr); else { - sprintf (ND_Error_Msg, "Error ND_Index_Node_Add : unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type); + sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Add_I: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type); ND_Error_Print (); return(NDS_ERRAPI); } @@ -2262,22 +2835,32 @@ NDT_Status ND_Index_Node_Add_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND /*------------------------------------------------------------------------------*/ NDT_Status ND_Index_Node_Add_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr) -{ +{ + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Add_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf (ND_Error_Msg, "Error ND_Index_Node_Add : structure root is null"); + sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Add_C: structure root is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } if( !Node_Ptr) { - sprintf (ND_Error_Msg, "Error ND_Index_Node_Add : the node to add is null"); + sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Add_C: the node to add is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_Index_Node_Add_I( Root_Ptr, Index_Id, Node_Ptr); + return( ND_Index_Node_Add_I( Root_Ptr, Index_Id, Node_Ptr)); } @@ -2293,7 +2876,7 @@ NDT_Status ND_Index_Node_Add_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND NDT_Status ND_Index_Node_Remove_I( NDT_Node *Node_Ptr) { NDT_Root *root_ptr; - NDT_Index_Id index_id; + NDT_Index_Id index_id; root_ptr = Node_Ptr->Root; @@ -2327,9 +2910,9 @@ NDT_Status ND_Index_Node_Remove_I( NDT_Node *Node_Ptr) NDT_Node *First_Node_Ptr; /* - On sauve le fils gauche du noeud à supprimer dans un pointeur de - sauvegarde pour pouvoir le récupérer au cas où la procédure serait - interrompue (recovery). + On sauve le fils gauche du noeud à supprimer dans un pointeur de + sauvegarde pour pouvoir le récupérer au cas où la procédure serait + interrompue (recovery). */ root_ptr->Index_Tab[index_id].Save = Left_Node_Ptr; @@ -2376,7 +2959,7 @@ NDT_Status ND_Index_Node_Remove_I( NDT_Node *Node_Ptr) } else { - sprintf (ND_Error_Msg, "Error ND_Index_Node_Remove : unknown structure type (%d)", root_ptr->Index_Tab[index_id].Type); + sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Remove_I: unknown structure type (%d)", root_ptr->Index_Tab[index_id].Type); ND_Error_Print (); return(NDS_ERRAPI); } @@ -2396,14 +2979,23 @@ NDT_Status ND_Index_Node_Remove_I( NDT_Node *Node_Ptr) NDT_Status ND_Index_Node_Remove_C( NDT_Node *Node_Ptr) { - if( !Node_Ptr) + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf( ND_Error_Msg, "Error ND_Index_Node_Remove : the node to remove is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Remove_C: library is not open"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_Index_Node_Remove_I( Node_Ptr); + if( !Node_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Remove_C: the node to remove is null"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + + return( ND_Index_Node_Remove_I( Node_Ptr)); } @@ -2427,7 +3019,7 @@ NDT_Status ND_Index_Node_First_Get_I( NDT_Node **First_Node_Ptr_Ptr, NDT_Root // if(!*First_Node_Ptr_Ptr) return(NDS_KO); - return(NDS_OK); + return( NDS_OK); } @@ -2443,14 +3035,23 @@ NDT_Status ND_Index_Node_First_Get_I( NDT_Node **First_Node_Ptr_Ptr, NDT_Root NDT_Status ND_Index_Node_First_Get_C( NDT_Node **First_Node_Ptr_Ptr, NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) { - if( !Root_Ptr) + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf( ND_Error_Msg, "Error ND_Index_Node_First_Get : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_First_Get_C: library is not open"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_Index_Node_First_Get_I( First_Node_Ptr_Ptr, Root_Ptr, Index_Id); + if( !Root_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_First_Get_C: structure root is null"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + + return( ND_Index_Node_First_Get_I( First_Node_Ptr_Ptr, Root_Ptr, Index_Id)); } @@ -2474,7 +3075,7 @@ NDT_Status ND_Index_Node_Last_Get_I ( NDT_Node **Last_Node_Ptr_Ptr, NDT_Root * // if(!*Last_Node_Ptr_Ptr) return(NDS_KO); - return(NDS_OK); + return( NDS_OK); } @@ -2490,14 +3091,23 @@ NDT_Status ND_Index_Node_Last_Get_I ( NDT_Node **Last_Node_Ptr_Ptr, NDT_Root * NDT_Status ND_Index_Node_Last_Get_C( NDT_Node **Last_Node_Ptr_Ptr, NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) { - if( !Root_Ptr) + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf( ND_Error_Msg, "Error ND_Index_Node_Last_Get : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Last_Get_C: library is not open"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_Index_Node_Last_Get_I( Last_Node_Ptr_Ptr, Root_Ptr, Index_Id); + if( !Root_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Last_Get_C: structure root is null"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + + return( ND_Index_Node_Last_Get_I( Last_Node_Ptr_Ptr, Root_Ptr, Index_Id)); } @@ -2514,24 +3124,24 @@ NDT_Status ND_Index_Node_Last_Get_C( NDT_Node **Last_Node_Ptr_Ptr, NDT_Root * NDT_Status ND_Index_Node_Next_Get_I ( NDT_Node **Next_Node_Ptr_Ptr, NDT_Node *Node_Ptr) { if( ND_INDEX_TYPE_LIST_IS( Node_Ptr->Root, Node_Ptr->Index)) - { - *Next_Node_Ptr_Ptr = Node_Ptr->Right; - } + { + *Next_Node_Ptr_Ptr = Node_Ptr->Right; + } else if( ND_INDEX_TYPE_TREE_IS( Node_Ptr->Root, Node_Ptr->Index)) { if( !Node_Ptr->Right) - { - *Next_Node_Ptr_Ptr = ND_Tree_Parent_Next_Recursive_Get(Node_Ptr); - } + { + *Next_Node_Ptr_Ptr = ND_Tree_Parent_Next_Recursive_Get(Node_Ptr); + } else - { - *Next_Node_Ptr_Ptr = ND_Tree_Node_First_Recursive_Get(Node_Ptr->Right); - } + { + *Next_Node_Ptr_Ptr = ND_Tree_Node_First_Recursive_Get(Node_Ptr->Right); + } } // if(!*Next_Node_Ptr_Ptr) return(NDS_KO); - return(NDS_OK); + return( NDS_OK); } @@ -2547,14 +3157,23 @@ NDT_Status ND_Index_Node_Next_Get_I ( NDT_Node **Next_Node_Ptr_Ptr, NDT_Node * NDT_Status ND_Index_Node_Next_Get_C( NDT_Node **Next_Node_Ptr_Ptr, NDT_Node *Node_Ptr) { - if( !Node_Ptr) + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf( ND_Error_Msg, "Error ND_Index_Node_Next_Get : node is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Next_Get_C: library is not open"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_Index_Node_Next_Get_I( Next_Node_Ptr_Ptr, Node_Ptr); + if( !Node_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Next_Get_C: node is null"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + + return( ND_Index_Node_Next_Get_I( Next_Node_Ptr_Ptr, Node_Ptr)); } @@ -2575,13 +3194,13 @@ NDT_Status ND_Index_Node_Previous_Get_I( NDT_Node **Prev_Node_Ptr_Ptr, NDT_Nod if( ND_INDEX_TYPE_TREE_IS( Node_Ptr->Root, Node_Ptr->Index)) { if( !Node_Ptr->Left) - { - *Prev_Node_Ptr_Ptr = ND_Tree_Parent_Previous_Recursive_Get( Node_Ptr); - } + { + *Prev_Node_Ptr_Ptr = ND_Tree_Parent_Previous_Recursive_Get( Node_Ptr); + } else - { - *Prev_Node_Ptr_Ptr = ND_Tree_Node_Last_Recursive_Get( Node_Ptr->Left); - } + { + *Prev_Node_Ptr_Ptr = ND_Tree_Node_Last_Recursive_Get( Node_Ptr->Left); + } } // if( !*Prev_Node_Ptr_Ptr) return( NDS_KO); @@ -2602,14 +3221,23 @@ NDT_Status ND_Index_Node_Previous_Get_I( NDT_Node **Prev_Node_Ptr_Ptr, NDT_Nod NDT_Status ND_Index_Node_Previous_Get_C( NDT_Node **Prev_Node_Ptr_Ptr, NDT_Node *Node_Ptr) { - if( !Node_Ptr) + if( NDG_Base.Open_Status != NDD_TRUE) { - sprintf( ND_Error_Msg, "Error ND_Index_Node_Previous_Get : node is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Previous_Get_C: library is not open"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } - return ND_Index_Node_Previous_Get_I( Prev_Node_Ptr_Ptr, Node_Ptr); + if( !Node_Ptr) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Previous_Get_C: node is null"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + + return( ND_Index_Node_Previous_Get_I( Prev_Node_Ptr_Ptr, Node_Ptr)); } @@ -2637,8 +3265,10 @@ NDT_Status ND_Index_Node_Find_VI( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr } else { - sprintf (ND_Error_Msg, "Error ND_Index_Node_Find_VI: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type); + sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Find_VI: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type); ND_Error_Print (); + + return( NDS_KO); } return( NDS_OK); @@ -2662,18 +3292,27 @@ NDT_Status ND_Index_Node_Find_VC( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr NDT_Status status; + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_VC: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Node_Find_VC: structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_VC: structure root is null"); ND_Error_Print(); + return( NDS_ERRAPI); } if( !Value_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Node_Find_VC: the value to find is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_VC: the value to find is null"); ND_Error_Print(); + return( NDS_ERRAPI); } @@ -2713,7 +3352,7 @@ NDT_Status ND_Index_Node_Find_I( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr, } else { - sprintf (ND_Error_Msg, "Error ND_Index_Node_Find_I: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type); + sprintf (NDG_Base.Err_String, "Error ND_Index_Node_Find_I: unknown structure type (%d)", Root_Ptr->Index_Tab[Index_Id].Type); ND_Error_Print (); } @@ -2743,17 +3382,27 @@ NDT_Status ND_Index_Node_Find_C( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr, va_start( user_args, Value_Ptr); + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Node_Find_C: structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_C: structure root is null"); ND_Error_Print(); + return( NDS_ERRAPI); } if( !Value_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Index_Node_Find_C: the value to find is null"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Node_Find_C: the value to find is null"); ND_Error_Print(); + return( NDS_ERRAPI); } @@ -2785,7 +3434,7 @@ NDT_Status ND_DataStruct_Value_Find_VI( void **Value_Ptr_Ptr, NDT_Root *Root_ NDT_Node *node_ptr; - status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_INDEX_GET, &new_index, &new_cmd, NDD_CMD_VALUE_FIND, Ref_Value_Ptr); + status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_PRIMARY, NULL, NDD_CMD_INDEX_GET, &new_index, &new_cmd, NDD_CMD_VALUE_FIND, Ref_Value_Ptr); if( ND_ERROR(status)) return( status); status = ND_Index_Node_Find_VI( &node_ptr, Root_Ptr, new_index, Ref_Value_Ptr, Args); @@ -2821,17 +3470,27 @@ NDT_Status ND_DataStruct_Value_Find_VC( void **Value_Ptr_Ptr, NDT_Root *Root_ NDT_Status status; + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_VC: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Value_Find_VC: structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_VC: structure root is null"); ND_Error_Print(); + return( NDS_ERRAPI); } if( !Ref_Value_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Value_Find_VC: the ref value to find is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_VC: the ref value to find is null"); ND_Error_Print(); + return( NDS_ERRAPI); } @@ -2905,17 +3564,27 @@ NDT_Status ND_DataStruct_Value_Find_C( void **Value_Ptr_Ptr, NDT_Root *Root_P va_start( user_args, Ref_Value_Ptr); + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Value_Find_C: structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_C: structure root is null"); ND_Error_Print(); + return( NDS_ERRAPI); } if( !Ref_Value_Ptr) { - sprintf( ND_Error_Msg, "Error ND_DataStruct_Value_Find_C: the ref value to find is null"); + sprintf( NDG_Base.Err_String, "Error ND_DataStruct_Value_Find_C: the ref value to find is null"); ND_Error_Print(); + return( NDS_ERRAPI); } @@ -2957,14 +3626,23 @@ NDT_Status ND_Node_Root_Get_I( NDT_Root **Root_Ptr_Ptr, NDT_Node *Node_Ptr) NDT_Status ND_Node_Root_Get_C( NDT_Root **Root_Ptr_Ptr, NDT_Node *Node_Ptr ) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Node_Root_Get_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Node_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Node_Root_Get : node is null"); + sprintf( NDG_Base.Err_String, "Error ND_Node_Root_Get_C: node is null"); ND_Error_Print(); + return(NDS_ERRAPI); } - return ND_Node_Root_Get_I( Root_Ptr_Ptr, Node_Ptr); + return( ND_Node_Root_Get_I( Root_Ptr_Ptr, Node_Ptr)); } @@ -2991,11 +3669,11 @@ NDT_Status ND_Value_Alloc_I( NDT_Root *Root_Ptr, void **Value_Ptr_Ptr, ...) /* Appel du manager */ - rc = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_VALUE_ALLOC, Value_Ptr_Ptr, user_args); + rc = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_VALUE_ALLOC, Value_Ptr_Ptr, user_args); va_end( user_args); - return rc; + return( rc); } @@ -3016,11 +3694,20 @@ NDT_Status ND_Value_Alloc_C( NDT_Root *Root_Ptr, void **Value_Ptr_Ptr, ...) va_list user_args; + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Value_Alloc_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Value_Alloc : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Value_Alloc_C: structure root is null"); ND_Error_Print(); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } /* Récupération des arguments pour l'allocation de la valeur */ @@ -3049,7 +3736,7 @@ NDT_Status ND_Value_Alloc_C( NDT_Root *Root_Ptr, void **Value_Ptr_Ptr, ...) NDT_Status ND_Value_Free_I( NDT_Root *Root_Ptr, void *Value_Ptr) { - return ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_VALUE_FREE, Value_Ptr); + return( ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_VALUE_FREE, Value_Ptr)); } @@ -3064,17 +3751,27 @@ NDT_Status ND_Value_Free_I( NDT_Root *Root_Ptr, void *Value_Ptr) /*------------------------------------------------------------------------------*/ NDT_Status ND_Value_Free_C( NDT_Root *Root_Ptr, void *Value_Ptr) { + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Value_Free_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Value_Free_C : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Value_Free_C: structure root is null"); ND_Error_Print(); + return( NDS_ERRAPI); } if( !Value_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Value_Free_C : the value to free is null"); + sprintf( NDG_Base.Err_String, "Error ND_Value_Free_C: the value to free is null"); ND_Error_Print(); + return( NDS_ERRAPI); } @@ -3099,7 +3796,7 @@ NDT_Status ND_Manager_Exec_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT NDT_Manager *manager_ptr; - manager_ptr = Root_Ptr->Manager_Ptr; // Win32 + manager_ptr = Root_Ptr->Manager_Ptr; // Win32 status = manager_ptr( Root_Ptr, Index_Id, Node_Ptr, Command, Args); @@ -3120,23 +3817,33 @@ NDT_Status ND_Manager_Exec_VC( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT NDT_Status status; + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_VC: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Manager_Exec_VC : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_VC: structure root is null"); ND_Error_Print(); + return( NDS_ERRAPI); } if( !Root_Ptr->Manager_Ptr || !*(Root_Ptr->Manager_Ptr)) { - sprintf( ND_Error_Msg, "Error ND_Manager_Exec_VC : undefined function name"); + sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_VC: undefined function name"); ND_Error_Print(); + return( NDS_ERRAPI); } status = ND_Manager_Exec_VI( Root_Ptr, Index_Id, Node_Ptr, Command, Args); - return(status); + return( status); } @@ -3156,13 +3863,13 @@ NDT_Status ND_Manager_Exec_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_ NDT_Manager *manager_ptr; - va_start( args, Command); + va_start( args, Command); - manager_ptr = Root_Ptr->Manager_Ptr; // Win32 + manager_ptr = Root_Ptr->Manager_Ptr; // Win32 status = manager_ptr( Root_Ptr, Index_Id, Node_Ptr, Command, args); - va_end( args); + va_end( args); return( status); } @@ -3180,30 +3887,40 @@ NDT_Status ND_Manager_Exec_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_ NDT_Status ND_Manager_Exec_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, ...) { NDT_Status status; - va_list args; + va_list args; - va_start( args, Command); + va_start( args, Command); + + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } if( !Root_Ptr) { - sprintf( ND_Error_Msg, "Error ND_Manager_Exec_C : structure root is null"); + sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_C: structure root is null"); ND_Error_Print(); + return( NDS_ERRAPI); } if( !Root_Ptr->Manager_Ptr || !*(Root_Ptr->Manager_Ptr)) { - sprintf( ND_Error_Msg, "Error ND_Manager_Exec_C : undefined function name"); + sprintf( NDG_Base.Err_String, "Error ND_Manager_Exec_C: undefined function name"); ND_Error_Print(); + return( NDS_ERRAPI); } status = ND_Manager_Exec_VI( Root_Ptr, Index_Id, Node_Ptr, Command, args); - va_end( args); + va_end( args); - return(status); + return( status); } @@ -3225,7 +3942,7 @@ NDT_Status ND_Allocator_Exec_I( NDT_Allocator *Function, void **Ptr_Ptr, size *Ptr_Ptr = NULL; - allocator_ptr = Function; + allocator_ptr = Function; return allocator_ptr( Size, Ptr_Ptr, Data_Ptr); } @@ -3248,18 +3965,27 @@ NDT_Status ND_Allocator_Exec_C ( NDT_Allocator *Function, void **Ptr_Ptr, siz NDT_Allocator *Allocator_Ptr; + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Allocator_Exec_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + *Ptr_Ptr = NULL; if(!Function || !*Function) { - sprintf( ND_Error_Msg, "Error ND_Allocator_Exec : undefined function name"); + sprintf( NDG_Base.Err_String, "Error ND_Allocator_Exec_C: undefined function name"); ND_Error_Print (); - return(NDS_ERRAPI); + + return( NDS_ERRAPI); } Allocator_Ptr = Function; - if( !Allocator_Ptr) return(NDS_ERRAPI); + if( !Allocator_Ptr) return( NDS_ERRAPI); return( Allocator_Ptr (Size, Ptr_Ptr, Data_Ptr)); } @@ -3280,9 +4006,9 @@ NDT_Status ND_Desallocator_Exec_I( NDT_Desallocator *Function, void *Ptr, void { NDT_Desallocator *desallocator_ptr; - desallocator_ptr = Function; + desallocator_ptr = Function; - return desallocator_ptr( Ptr, Data_Ptr); + return( desallocator_ptr( Ptr, Data_Ptr)); } @@ -3302,18 +4028,27 @@ NDT_Status ND_Desallocator_Exec_C( NDT_Desallocator *Function, void *Ptr, voi NDT_Desallocator *desallocator_ptr; + if( NDG_Base.Open_Status != NDD_TRUE) + { + sprintf( NDG_Base.Err_String, "Error ND_Desallocator_Exec_C: library is not open"); + ND_Error_Print(); + + return( NDS_ERRAPI); + } + if (!Function || !*Function) { - sprintf (ND_Error_Msg, "Error ND_Desallocator_Exec : undefined function name"); + sprintf (NDG_Base.Err_String, "Error ND_Desallocator_Exec_C: undefined function name"); ND_Error_Print (); - return NDS_ERRAPI; + + return( NDS_ERRAPI); } desallocator_ptr = Function; if( !desallocator_ptr) return( NDS_ERRAPI); - return desallocator_ptr( Ptr, Data_Ptr); + return( desallocator_ptr( Ptr, Data_Ptr)); } @@ -3338,37 +4073,39 @@ NDT_Status ND_Desallocator_Exec_C( NDT_Desallocator *Function, void *Ptr, voi /*------------------------------------------------------------------------------*/ /* Recherche d'un symbole */ /*------------------------------------------------------------------------------*/ -void * ND_Symbol_Find ( const char * Symbol_Name ) +void *ND_Symbol_Find( const char *Symbol_Name) { - struct Symbol * Symbol; - void * Ptr = NULL; + NDT_Symbol *Symbol_Ptr; + void *Ptr = NULL; /* Recherche du symbole dans la table des symboles locale */ - Symbol = Symbol_Table; - while (Symbol) + Symbol_Ptr = NDG_Base.Symbol_First_Ptr; + + while( Symbol_Ptr) { - if (!strcmp (Symbol->Name, Symbol_Name)) return Symbol->Ptr; - else Symbol = Symbol->Next; + if( !strcmp( Symbol_Ptr->Name, Symbol_Name)) return( Symbol_Ptr->Ptr); + else Symbol_Ptr = Symbol_Ptr->Next; } /* Si le symbole n'a pas été trouvée dans la table des symboles locale, on l'y ajoute */ -// Ptr = dlsym (RTLD_DEFAULT, (const char *) Symbol_Name); - if (!Ptr) +// Ptr = dlsym( RTLD_DEFAULT, (const char *)Symbol_Name); + if( !Ptr) { - sprintf (ND_Error_Msg, "Error ND_Symbol_Find : unable to find \"%s\"' in symbol table (%s)", Symbol_Name, NULL/*dlerror ()*/); + sprintf( NDG_Base.Err_String, "Error ND_Symbol_Find: unable to find \"%s\"' in symbol table (%s)", Symbol_Name, NULL/*dlerror ()*/); ND_Error_Print (); return NULL; } - Symbol = (struct Symbol *) malloc (sizeof (struct Symbol)); - if (Symbol) + Symbol_Ptr = (NDT_Symbol *)malloc( sizeof( NDT_Symbol)); + if( Symbol_Ptr) { - Symbol->Name = strdup (Symbol_Name); - Symbol->Ptr = Ptr; - Symbol->Next = Symbol_Table; - Symbol_Table = Symbol; + Symbol_Ptr->Name = strdup (Symbol_Name); + Symbol_Ptr->Ptr = Ptr; + Symbol_Ptr->Next = NDG_Base.Symbol_First_Ptr; + + NDG_Base.Symbol_First_Ptr = Symbol_Ptr; } return Ptr; @@ -3413,7 +4150,7 @@ NDT_Status ND_Node_Alloc( NDT_Root *Root_Ptr, NDT_Node **Node_Ptr_Ptr ) /* (I) Root: pointeur sur la racine de la structure */ /* (I) Node : pointeur sur le noeud à détruire */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Node_Free ( NDT_Root *Root_Ptr, NDT_Node *Node_Ptr) +NDT_Status ND_Node_Free( NDT_Root *Root_Ptr, NDT_Node *Node_Ptr) { return ND_Desallocator_Exec_I( Root_Ptr->Desallocator_Ptr, Node_Ptr, Root_Ptr->User); } @@ -3503,7 +4240,7 @@ NDT_Status ND_Node_Root_Alloc( NDT_Root **Root_Ptr_Ptr, NDT_Index_Nb Index_Nb, { if( ( status = ND_Index_Clear( *Root_Ptr_Ptr, index_id)) != NDS_OK) { - sprintf( ND_Error_Msg, "Error ND_Index_Open_I: Index cleaning error"); + sprintf( NDG_Base.Err_String, "Error ND_Index_Open_I: Index cleaning error"); ND_Error_Print(); return( NDS_KO); } @@ -3551,14 +4288,14 @@ NDT_Status ND_List_Node_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_N New_Node_Ptr->Root = Root_Ptr; - New_Node_Ptr->Index = Index_Id; + New_Node_Ptr->Index = Index_Id; New_Node_Ptr->Parent = New_Node_Ptr->Left = New_Node_Ptr->Right = NULL; /* - Une liste triée peut être orientée de 2 manières : + Une liste triée peut être orientée de 2 manières : - - FIFO : un noeud sera inséré APRES un noeud de même valeur (par défaut) - - FILO : un noeud sera inséré AVANT un noeud de même valeur + - FIFO : un noeud sera inséré APRES un noeud de même valeur (par défaut) + - FILO : un noeud sera inséré AVANT un noeud de même valeur */ if( ND_INDEX_SUBTYPE_LIFO_IS( Root_Ptr, Index_Id)) @@ -3572,7 +4309,7 @@ NDT_Status ND_List_Node_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_N rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, New_Node_Ptr->Value, node_ptr->Value, NULL); if(rc == NDS_GREATER) - node_ptr = node_ptr->Right; + node_ptr = node_ptr->Right; else { /* On insère avant le noeud courant si le nouveau noeud est de valeur inférieure ou égale */ @@ -3608,7 +4345,7 @@ NDT_Status ND_List_Node_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_N node_ptr = Root_Ptr->Index_Tab[Index_Id].Tail; while( node_ptr) { - rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, New_Node_Ptr->Value, node_ptr->Value, NULL); + rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, New_Node_Ptr->Value, node_ptr->Value, NULL); /* On insère après le noeud courant si le nouveau noeud est de valeur strictement supérieure ou égale */ @@ -3651,7 +4388,7 @@ NDT_Status ND_List_Node_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_N if( ND_INDEX_SUBTYPE_FIFO_IS( Root_Ptr, Index_Id)) { New_Node_Ptr->Root = Root_Ptr; - New_Node_Ptr->Index = Index_Id; + New_Node_Ptr->Index = Index_Id; New_Node_Ptr->Parent = NULL; New_Node_Ptr->Left = Root_Ptr->Index_Tab[Index_Id].Tail; New_Node_Ptr->Right = NULL; @@ -3671,7 +4408,7 @@ NDT_Status ND_List_Node_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_N { New_Node_Ptr->Root = Root_Ptr; - New_Node_Ptr->Index = Index_Id; + New_Node_Ptr->Index = Index_Id; New_Node_Ptr->Parent = NULL; New_Node_Ptr->Left = NULL; New_Node_Ptr->Right = Root_Ptr->Index_Tab[Index_Id].Head; @@ -3686,8 +4423,8 @@ NDT_Status ND_List_Node_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_N } } - printf( "ND_List_Node_Add : unknown list type (%d)\n", Root_Ptr->Index_Tab[Index_Id].Type); - return(NDS_ERRAPI); + printf( "ND_List_Node_Add: unknown list type (%d)\n", Root_Ptr->Index_Tab[Index_Id].Type); + return( NDS_ERRAPI); } @@ -3714,15 +4451,15 @@ NDT_Status ND_List_Value_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void // return ND_List_Node_Add (Root, Node); - rc = ND_List_Node_Add( Root_Ptr, Index_Id, node_ptr); + rc = ND_List_Node_Add( Root_Ptr, Index_Id, node_ptr); if( ND_ERROR(rc)) - { - return( rc); - } - else - { - return( ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_ADD, Value_Ptr, NULL)); - } + { + return( rc); + } + else + { + return( ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_ADD, Value_Ptr, NULL)); + } } @@ -3749,15 +4486,15 @@ NDT_Status ND_Tree_Value_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void // return ND_Tree_Node_Add (Root, Node); - rc = ND_Tree_Node_Add( Root_Ptr, Index_Id, node_ptr); + rc = ND_Tree_Node_Add( Root_Ptr, Index_Id, node_ptr); if( ND_ERROR(rc)) - { - return( rc); - } - else - { - return ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_ADD, Value_Ptr, NULL); - } + { + return( rc); + } + else + { + return ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_ADD, Value_Ptr, NULL); + } } @@ -3791,22 +4528,22 @@ NDT_Node *ND_List_Node_Find( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void switch (rc) { case NDS_EQUAL: - { + { return(node_ptr); - } + } case NDS_LOWER: - { + { /* Ce n'est pas a peine de continuer car on a déjà dépassé la valeur recherchée */ return(NULL); - } + } case NDS_GREATER: - { + { node_ptr = node_ptr->Right; break; - } + } } } } @@ -3815,12 +4552,12 @@ NDT_Node *ND_List_Node_Find( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void /* Pour les listes non triées, il faut parcourir toute la liste */ while( node_ptr && ( ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, Value_Ptr, node_ptr->Value, User_Args) != NDS_EQUAL)) - { + { node_ptr = node_ptr->Right; - } + } } - return node_ptr; + return( node_ptr); } @@ -3856,7 +4593,7 @@ NDT_Node *ND_Tree_Node_Recursive_Find( NDT_Node *Node_Ptr, void *Value_Ptr, v if( answer == NDS_GREATER) return( ND_Tree_Node_Recursive_Find( Node_Ptr->Right, Value_Ptr, User_Args)); - return(NULL); + return( NULL); } @@ -3959,7 +4696,7 @@ NDT_Status ND_List_Recursive_Make( NDT_Node *Node_Ptr, NDT_Root *Root_Ptr, ND if( ND_List_Node_Add( Root_Ptr, Index_Id, Node_Ptr) != NDS_OK) return NDS_KO; - return ND_List_Recursive_Make( right_node_ptr, Root_Ptr, Index_Id); + return( ND_List_Recursive_Make( right_node_ptr, Root_Ptr, Index_Id)); } @@ -4001,6 +4738,7 @@ NDT_Node *ND_Tree_Recursive_Make( long Depth, long Node_Number, NDT_Node *No long middle_pos, left_len, right_len, i; NDT_Node *left_node_ptr, *middle_node_ptr, *right_node_ptr; + if( !Node_Ptr) return (NULL); /* On calcule le milieu de la liste */ @@ -4053,19 +4791,19 @@ NDT_Node *ND_Tree_Recursive_Make( long Depth, long Node_Number, NDT_Node *No if( !middle_node_ptr->Left && !middle_node_ptr->Right) { /* - Si le noeud courant est une feuille, on met éventuellement à jour - les longueurs minimale et maximale des branches de l'arbre + Si le noeud courant est une feuille, on met éventuellement à jour + les longueurs minimale et maximale des branches de l'arbre */ if( Depth > middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Max_Depth) - { - middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Max_Depth = Depth; - } + { + middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Max_Depth = Depth; + } if( Depth < middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Min_Depth) - { - middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Min_Depth = Depth; - } + { + middle_node_ptr->Root->Index_Tab[middle_node_ptr->Index].Min_Depth = Depth; + } } return( middle_node_ptr); @@ -4126,7 +4864,7 @@ NDT_Status ND_Tree_Equalize( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) type = Root_Ptr->Index_Tab[Index_Id].Type; // strcpy( Manager, Root_Ptr->Manager); // Win32 - manager = Root_Ptr->Manager_Ptr; // Win32 + manager = Root_Ptr->Manager_Ptr; // Win32 max_dif = Root_Ptr->Index_Tab[Index_Id].Max_Dif; nb_equ = Root_Ptr->Index_Tab[Index_Id].Nb_Equ; @@ -4140,11 +4878,11 @@ NDT_Status ND_Tree_Equalize( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) Root_Ptr->Index_Tab[Index_Id].Type = type; // strcpy( Root_Ptr->Manager, Manager); // Win32 - Root_Ptr->Manager_Ptr = manager; // Win32 + Root_Ptr->Manager_Ptr = manager; // Win32 Root_Ptr->Index_Tab[Index_Id].Max_Dif = max_dif; Root_Ptr->Index_Tab[Index_Id].Nb_Equ = nb_equ + 1; - return(NDS_OK); + return( NDS_OK); } @@ -4161,6 +4899,7 @@ long ND_Tree_MaxDepth_Get( NDT_Node *Node_Ptr) { long Max_Left, Max_Right; + if( !Node_Ptr) return ( 0); Max_Left = ND_Tree_MaxDepth_Get( Node_Ptr->Left); @@ -4236,7 +4975,7 @@ void ND_Tree_Node_Recursive_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, N if( Max_Depth + Depth - 1 > Root_Ptr->Index_Tab[Index_Id].Max_Depth) Root_Ptr->Index_Tab[Index_Id].Max_Depth = Max_Depth + Depth - 1; - if (Min_Depth + Depth - 1 < Root_Ptr->Index_Tab[Index_Id].Min_Depth) Root_Ptr->Index_Tab[Index_Id].Min_Depth = Min_Depth + Depth - 1; + if (Min_Depth + Depth - 1 < Root_Ptr->Index_Tab[Index_Id].Min_Depth) Root_Ptr->Index_Tab[Index_Id].Min_Depth = Min_Depth + Depth - 1 ; } } @@ -4249,9 +4988,9 @@ NDT_Status ND_Tree_Node_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_N ND_Tree_Node_Recursive_Add( Root_Ptr, Index_Id, NULL, &(Root_Ptr->Index_Tab[Index_Id].Head), 1, Node_Ptr); if( ND_INDEX_SUBTYPE_BALANCED_IS( Root_Ptr, Index_Id) && Root_Ptr->Index_Tab[Index_Id].Max_Depth - Root_Ptr->Index_Tab[Index_Id].Min_Depth > Root_Ptr->Index_Tab[Index_Id].Max_Dif) - return ND_Tree_Equalize( Root_Ptr, Index_Id); + return( ND_Tree_Equalize( Root_Ptr, Index_Id)); - return NDS_OK; + return( NDS_OK); } @@ -4280,7 +5019,7 @@ NDT_Status ND_Tree_List_Add( NDT_Root *Tree_Root_Ptr, NDT_Index_Id Tree_Index node_ptr = node_ptr->Right; } - return(NDS_OK); + return( NDS_OK); } @@ -4312,14 +5051,14 @@ void ND_Tree_Recursive_Print( NDT_Node *Node_Ptr, long Depth, FILE *Out) /* Affichage des toutes les informations (noeud et valeur) : - if (Node->Root) fprintf (Out, "Root=%p ", Node->Root); - if (Node->Parent) fprintf (Out, "Parent=%p ", Node->Parent); - if (Node->Left) fprintf (Out, "Left=%p ", Node->Left); - if (Node->Right) fprintf (Out, "Right=%p ", Node->Right); +if (Node->Root) fprintf (Out, "Root=%p ", Node->Root); +if (Node->Parent) fprintf (Out, "Parent=%p ", Node->Parent); +if (Node->Left) fprintf (Out, "Left=%p ", Node->Left); +if (Node->Right) fprintf (Out, "Right=%p ", Node->Right); - fprintf (Out, "Value=["); - ND_Manager_Exec (Node->Root->Manager, NDD_CMD_PRINT_VALUE, Node->Value, Out); - fprintf (Out, "]\n"); +fprintf (Out, "Value=["); +ND_Manager_Exec (Node->Root->Manager, NDD_CMD_PRINT_VALUE, Node->Value, Out); +fprintf (Out, "]\n"); */ /* Affichage de la valeur seule : */ @@ -4357,7 +5096,7 @@ int ND_Node_Compare( void **Node1_Ptr_Ptr, void **Node2_Ptr_Ptr) case NDS_GREATER: return 1; default: - sprintf( ND_Error_Msg, "Error ND_Node_Compare : incorrect return code from the manager: %d", rc); + sprintf( NDG_Base.Err_String, "Error ND_Node_Compare : incorrect return code from the manager: %d", rc); ND_Error_Print (); return 0; } @@ -4375,9 +5114,9 @@ int ND_Node_Compare( void **Node1_Ptr_Ptr, void **Node2_Ptr_Ptr) NDT_Status ND_List_Sort( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) { - int i; + int i; NDT_Node *node_ptr; - void **tab; + void **tab; if( Root_Ptr->Index_Tab[Index_Id].Node_Number < 2) return NDS_OK; @@ -4422,7 +5161,7 @@ NDT_Status ND_List_Sort( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id) free(tab); - return(NDS_OK); + return( NDS_OK); } @@ -4478,7 +5217,7 @@ NDT_Status ND_Default_Allocator( size_t Size, void **Ptr_Ptr, void *Data_Ptr if( !*Ptr_Ptr) return(NDS_ERRMEM); - return(NDS_OK); + return( NDS_OK); } @@ -4495,7 +5234,7 @@ NDT_Status ND_Default_Desallocator( void *Ptr, void *Data_Ptr) free( Ptr); - return(NDS_OK); + return( NDS_OK); } @@ -4528,13 +5267,13 @@ void ND_List_Check( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int *Nb_Detect void ND_List_Link_Check( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int *Nb_Detected_Ptr, int *Nb_Corrected_Ptr, FILE *Out) { NDT_Node *node_ptr; - int left2right_node_number = 0; - int right2left_node_number = 0; + int left2right_node_number = 0; + int right2left_node_number = 0; /* - On commence à vérifier si l'on trouve le même nombre de noeuds - en parcourant la liste de droite à gauche, puis de gauche à droite + On commence à vérifier si l'on trouve le même nombre de noeuds + en parcourant la liste de droite à gauche, puis de gauche à droite */ node_ptr = Root_Ptr->Index_Tab[Index_Id].Head; @@ -4578,18 +5317,18 @@ void ND_List_Link_Check( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int *Nb_D { if( node_ptr->Right && ( node_ptr->Right->Left != node_ptr)) { - fprintf( Out, "\t- link 'Left' has been corrected on node %p of structure %p:%d\n", node_ptr->Right, Root_Ptr, Index_Id); - node_ptr->Right->Left = node_ptr; - (*Nb_Detected_Ptr)++; - (*Nb_Corrected_Ptr)++; + fprintf( Out, "\t- link 'Left' has been corrected on node %p of structure %p:%d\n", node_ptr->Right, Root_Ptr, Index_Id); + node_ptr->Right->Left = node_ptr; + (*Nb_Detected_Ptr)++; + (*Nb_Corrected_Ptr)++; } if( !node_ptr->Right && ( node_ptr != Root_Ptr->Index_Tab[Index_Id].Tail)) { - fprintf( Out, "\t- link 'Tail' has been corrected on structure %p:%d\n", Root_Ptr, Index_Id); - Root_Ptr->Index_Tab[Index_Id].Tail = node_ptr; - (*Nb_Detected_Ptr)++; - (*Nb_Corrected_Ptr)++; + fprintf( Out, "\t- link 'Tail' has been corrected on structure %p:%d\n", Root_Ptr, Index_Id); + Root_Ptr->Index_Tab[Index_Id].Tail = node_ptr; + (*Nb_Detected_Ptr)++; + (*Nb_Corrected_Ptr)++; } node_ptr = node_ptr->Right; @@ -4616,18 +5355,18 @@ void ND_List_Link_Check( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int *Nb_D { if( node_ptr->Left && ( node_ptr->Left->Right != node_ptr)) { - fprintf( Out, "\t- link 'Right' has been corrected on node %p of list %p:%d\n", node_ptr->Left, Root_Ptr, Index_Id); - node_ptr->Left->Right = node_ptr; - (*Nb_Detected_Ptr)++; - (*Nb_Corrected_Ptr)++; + fprintf( Out, "\t- link 'Right' has been corrected on node %p of list %p:%d\n", node_ptr->Left, Root_Ptr, Index_Id); + node_ptr->Left->Right = node_ptr; + (*Nb_Detected_Ptr)++; + (*Nb_Corrected_Ptr)++; } if( !node_ptr->Left && ( node_ptr != Root_Ptr->Index_Tab[Index_Id].Head)) { - fprintf( Out, "\t- link 'Head' has been corrected on the structure root %p:%d\n", Root_Ptr, Index_Id); - Root_Ptr->Index_Tab[Index_Id].Head = node_ptr; - (*Nb_Detected_Ptr)++; - (*Nb_Corrected_Ptr)++; + fprintf( Out, "\t- link 'Head' has been corrected on the structure root %p:%d\n", Root_Ptr, Index_Id); + Root_Ptr->Index_Tab[Index_Id].Head = node_ptr; + (*Nb_Detected_Ptr)++; + (*Nb_Corrected_Ptr)++; } node_ptr = node_ptr->Left; @@ -4668,7 +5407,7 @@ void ND_Value_Check( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int *Nb_Dete { fprintf( Out, "\t- node %p has been removed from structure %p:%d because no value is attached to it\n", node_ptr, Root_Ptr, Index_Id); - ND_Index_Node_Remove( node_ptr); + ND_Index_Node_Remove_I( node_ptr); node_ptr = next_node_ptr; @@ -4679,7 +5418,7 @@ void ND_Value_Check( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int *Nb_Dete { fprintf (Out, "\t- node %p has been removed from structure %p:%d because its value cannot be accessed\n", node_ptr, Root_Ptr, Index_Id); - ND_Index_Node_Remove( node_ptr); + ND_Index_Node_Remove_I( node_ptr); node_ptr = next_node_ptr; @@ -4740,8 +5479,8 @@ void ND_Tree_Link_Check( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int *Nb_ } /* - On vérifie si le lien 'Save' contient un noeud (cela signifie - que la procédure ND_Node_Remove n'a pas été jusqu'à son terme). + On vérifie si le lien 'Save' contient un noeud (cela signifie + que la procédure ND_Node_Remove n'a pas été jusqu'à son terme). */ if( Root_Ptr->Index_Tab[Index_Id].Save) @@ -4751,9 +5490,9 @@ void ND_Tree_Link_Check( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, int *Nb_ /* On attache le noeud contenu dans 'Save' à l'arbre s'il n'existe pas déjà */ - if( ND_Index_Node_Find( &node_ptr, Root_Ptr, Index_Id, Root_Ptr->Index_Tab[Index_Id].Save->Value, NULL) != NDS_OK) + if( ND_Index_Node_Find_I( &node_ptr, Root_Ptr, Index_Id, Root_Ptr->Index_Tab[Index_Id].Save->Value, NULL) != NDS_OK) { - ND_Index_Node_Add( Root_Ptr, Index_Id, Root_Ptr->Index_Tab[Index_Id].Save); + ND_Index_Node_Add_I( Root_Ptr, Index_Id, Root_Ptr->Index_Tab[Index_Id].Save); fprintf( Out, "\t- saved node %p has been restored to structure %p:%d\n", Root_Ptr->Index_Tab[Index_Id].Save, Root_Ptr, Index_Id); (*Nb_Detected_Ptr)++; (*Nb_Corrected_Ptr)++; @@ -4829,23 +5568,23 @@ NDT_Status ND_Address_Check( void *Address) int test; - Sig_Trapped = 0; + NDG_Base.Sig_Trapped = 0; /* On trappe les signaux SIGBUS et SIGSEGV */ -// signal (SIGBUS, ND_Signal_Trap); Win32 -// signal (SIGSEGV, ND_Signal_Trap); Win32 +// signal( SIGBUS, NDG_Base.Signal_Trap); Win32 +// signal( SIGSEGV, NDG_Base.Signal_Trap); Win32 /* On tente d'accéder à l'adresse fournie */ test = *( (int *)Address); -// sigrelse (SIGBUS); Win32 -// sigrelse (SIGSEGV); Win32 +// sigrelse( SIGBUS); Win32 +// sigrelse( SIGSEGV); Win32 - if( Sig_Trapped != 0) return(NDS_KO); + if( NDG_Base.Sig_Trapped != 0) return( NDS_KO); - return(NDS_OK); + return( NDS_OK); } @@ -4858,7 +5597,7 @@ NDT_Status ND_Address_Check( void *Address) void ND_Signal_Trap( int Sig_Num) { - Sig_Trapped = Sig_Num; + NDG_Base.Sig_Trapped = Sig_Num; } @@ -4871,5 +5610,5 @@ void ND_Signal_Trap( int Sig_Num) void ND_Error_Print( void) { - if( ND_stderr) fprintf( ND_stderr, "%s\n", ND_Error_Msg); + if( NDG_Base.Err_Stream) fprintf( ( NDG_Base.Err_Stream == (FILE *)-1 ) ? stderr : NDG_Base.Err_Stream, "%s\n", NDG_Base.Err_String); } diff --git a/lib/libnode.h b/lib/libnode.h index 17285bd..3d1ac91 100644 --- a/lib/libnode.h +++ b/lib/libnode.h @@ -1,10 +1,10 @@ /*---------------------------------------------------------------------------------*/ -/* $RCSfile: libnode.h,v $ */ +/* $RCSfile: libnode.h,v $ */ /*---------------------------------------------------------------------------------*/ -/* $Revision: 2.4 $ */ -/* $Name: $ */ -/* $Date: 2002/07/29 14:53:51 $ */ -/* $Author: agibert $ */ +/* $Revision: 2.5 $ */ +/* $Name: $ */ +/* $Date: 2004/08/01 23:18:38 $ */ +/* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/ @@ -21,7 +21,7 @@ /* GNU Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public License */ -/* along with Foobar; if not, write to the Free Software */ +/* along with LibNode; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /*---------------------------------------------------------------------------------*/ @@ -43,13 +43,9 @@ #ifdef __linux - # define NDD_PRINTF_PTR_PREFIX "" - #else - # define NDD_PRINTF_PTR_PREFIX "0x" - #endif @@ -58,24 +54,52 @@ #define NDD_HUGE_LONG (long)0xFFFFFFL -/* Sortie standard des messages d'erreur */ -FILE * ND_stderr; /* Table des symboles locale */ -struct Symbol { - void * Ptr; - char * Name; - struct Symbol * Next; -} * Symbol_Table = NULL; +struct NDT_Symbol; + +typedef struct NDT_Symbol +{ + void *Ptr; + char *Name; + struct NDT_Symbol *Next; +} NDT_Symbol; + + + +/* LibNode Global Base Structure */ + +typedef struct NDT_Base +{ + int Open_Status; + int Debug_Mode; + char Err_String[512]; + FILE *Err_Stream; + int Sig_Trapped; + NDT_Symbol *Symbol_First_Ptr; + NDT_Index_Type OpenStruct_Index_Type[1]; + NDT_Root *OpenStruct_Ptr; +} NDT_Base; + +NDT_Base NDG_Base = +{ + NDD_FALSE, + NDD_TRUE, + "", + (FILE *)-1, + 0, + (NDT_Symbol *)NULL, + { NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO}, + (NDT_Root *)NULL +}; + -NDT_Root * Tmp_Root; -//extern char * strdup (const char *); //extern int sigrelse (int sig); -int Sig_Trapped; + /*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/ @@ -88,7 +112,14 @@ int Sig_Trapped; /*------------------------------------------------------------------------------*/ /* (I) va_list Arguments : Liste d'arguments contextuels */ /*------------------------------------------------------------------------------*/ -NDT_Status Default_Manager( NDT_Root *, NDT_Index_Id, NDT_Command, va_list); +NDT_Status ND_Default_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); + +/*------------------------------------------------------------------------------*/ +/* OpenStruct Manager */ +/*------------------------------------------------------------------------------*/ +/* (I) va_list Arguments : Liste d'arguments contextuels */ +/*------------------------------------------------------------------------------*/ +NDT_Status ND_OpenStruct_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); /*------------------------------------------------------------------------------*/ /* Redéfinition de la fonction malloc() avec retour de type NDT_Status */ @@ -106,7 +137,7 @@ NDT_Status ND_Default_Desallocator( void *, void *); /* (I) Root : adresse de la racine pour laquelle on crée un noeud */ /* (O) New_Node : adresse du pointeur sur le nouveau noeud */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Node_Alloc (NDT_Root * Root, NDT_Node ** New_Node); +NDT_Status ND_Node_Alloc( NDT_Root * Root, NDT_Node ** New_Node); /*------------------------------------------------------------------------------*/ /* Destruction d'un noeud */ @@ -114,7 +145,7 @@ NDT_Status ND_Node_Alloc (NDT_Root * Root, NDT_Node ** New_Node); /* (I) Root : adresse de la racine dans laquelle on détruit un noeud */ /* (I) Node : pointeur sur le noeud à détruire */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Node_Free (NDT_Root * Root, NDT_Node * Node); +NDT_Status ND_Node_Free( NDT_Root *, NDT_Node *); /*------------------------------------------------------------------------------*/ /* Création d'une nouvelle structure de données */ @@ -144,7 +175,7 @@ NDT_Status ND_Node_Root_Alloc( NDT_Root **, NDT_Index_Nb, NDT_Index_Type[], ch /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine à détruire */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Node_Root_Free (NDT_Root * Root); +NDT_Status ND_Node_Root_Free( NDT_Root *); /*------------------------------------------------------------------------------*/ /* Ajout d'un noeud à une liste chaînée */ @@ -152,7 +183,7 @@ NDT_Status ND_Node_Root_Free (NDT_Root * Root); /* (I) Root : pointeur sur la racine de la liste */ /* (I) New_Node : pointeur sur le noeud à ajouter */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_List_Node_Add (NDT_Root *, NDT_Index_Id, NDT_Node *); +NDT_Status ND_List_Node_Add( NDT_Root *, NDT_Index_Id, NDT_Node *); /*------------------------------------------------------------------------------*/ /* Ajout d'une nouvelle valeur à une liste */ @@ -160,7 +191,7 @@ NDT_Status ND_List_Node_Add (NDT_Root *, NDT_Index_Id, NDT_Node *); /* (I) Root : pointeur sur la racine de la liste */ /* (I) Value : pointeur sur la valeur à ajouter */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_List_Value_Add (NDT_Root *, NDT_Index_Id, void *); +NDT_Status ND_List_Value_Add( NDT_Root *, NDT_Index_Id, void *); /*------------------------------------------------------------------------------*/ /* Ajout d'un noeud à un arbre binaire */ @@ -168,31 +199,31 @@ NDT_Status ND_List_Value_Add (NDT_Root *, NDT_Index_Id, void *); /* (I) Root : pointeur sur la racine de l'arbre */ /* (I) Value : pointeur sur la valeur à ajouter */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Tree_Value_Add (NDT_Root *, NDT_Index_Id, void *); +NDT_Status ND_Tree_Value_Add( NDT_Root *, NDT_Index_Id, void *); /*------------------------------------------------------------------------------*/ /* Supprime le noeud d'une liste */ /*------------------------------------------------------------------------------*/ /* (I) Node : pointeur sur le noeud à supprimer */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_List_Node_Remove (NDT_Node *); +NDT_Status ND_List_Node_Remove( NDT_Node *); /*------------------------------------------------------------------------------*/ /* Conversion d'une structure en liste chaînée */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine du la structure à convertir */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_List_Make (NDT_Root *, NDT_Index_Id); +NDT_Status ND_List_Make( NDT_Root *, NDT_Index_Id); /*------------------------------------------------------------------------------*/ /* Recherche une valeur dans une liste et retourne le noeud correspondant */ /*------------------------------------------------------------------------------*/ -NDT_Node * ND_List_Node_Find (NDT_Root *, NDT_Index_Id, void *, va_list); +NDT_Node * ND_List_Node_Find( NDT_Root *, NDT_Index_Id, void *, va_list); /*------------------------------------------------------------------------------*/ /* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud */ /*------------------------------------------------------------------------------*/ -NDT_Node *ND_Tree_Node_Find( NDT_Root *, NDT_Index_Id, void *, va_list); +NDT_Node *ND_Tree_Node_Find( NDT_Root *, NDT_Index_Id, void *, va_list); /*------------------------------------------------------------------------------*/ /* Conversion d'une structure en arbre binaire */ @@ -200,28 +231,28 @@ NDT_Node *ND_Tree_Node_Find( NDT_Root *, NDT_Index_Id, void *, va_list); /* (I) Root : pointeur sur la racine du la structure à convertir */ /* (I) Type : type du futur arbre */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Tree_Make (NDT_Root *, NDT_Index_Id); +NDT_Status ND_Tree_Make( NDT_Root *, NDT_Index_Id); /*------------------------------------------------------------------------------*/ /* Equilibrage d'un arbre */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de l'arbre */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Tree_Equalize (NDT_Root *, NDT_Index_Id); +NDT_Status ND_Tree_Equalize( NDT_Root *, NDT_Index_Id); /*------------------------------------------------------------------------------*/ /* Retourne la profondeur de la plus grande branche à partir d'un noeud */ /*------------------------------------------------------------------------------*/ /* (I) Node : pointeur sur le noeud */ /*------------------------------------------------------------------------------*/ -long ND_Tree_MaxDepth_Get (NDT_Node *Node); +long ND_Tree_MaxDepth_Get( NDT_Node *); /*------------------------------------------------------------------------------*/ /* Retourne la profondeur de la plus petite branche à partir d'un noeud */ /*------------------------------------------------------------------------------*/ /* (I) Node : pointeur sur le noeud */ /*------------------------------------------------------------------------------*/ -long ND_Tree_MinDepth_Get (NDT_Node *Node); +long ND_Tree_MinDepth_Get( NDT_Node *); /*------------------------------------------------------------------------------*/ /* Ajout d'un noeud à un arbre binaire */ @@ -229,7 +260,7 @@ long ND_Tree_MinDepth_Get (NDT_Node *Node); /* (I) Root : pointeur sur la racine de l'arbre */ /* (I) Node : pointeur sur le noeud à ajouter */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Tree_Node_Add (NDT_Root *, NDT_Index_Id, NDT_Node *); +NDT_Status ND_Tree_Node_Add( NDT_Root *, NDT_Index_Id, NDT_Node *); /*------------------------------------------------------------------------------*/ /* Ajoute tous les noeud d'une liste à un arbre */ @@ -237,19 +268,19 @@ NDT_Status ND_Tree_Node_Add (NDT_Root *, NDT_Index_Id, NDT_Node *); /* (I) Tree_Root : pointeur sur la racine de l'arbre */ /* (I) List_Root : pointeur sur la racine de la liste */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Tree_List_Add (NDT_Root *, NDT_Index_Id, NDT_Root *, NDT_Index_Id); +NDT_Status ND_Tree_List_Add( NDT_Root *, NDT_Index_Id, NDT_Root *, NDT_Index_Id); /*------------------------------------------------------------------------------*/ /* Fonction de comparaison de noeuds (pour le quick sort) */ /*------------------------------------------------------------------------------*/ -int ND_Node_Compare (void ** Node1, void ** Node2); +int ND_Node_Compare( void **, void **); /*------------------------------------------------------------------------------*/ /* Ordonne une liste chaînée selon l'algorithme du tri à bulle */ /*------------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la liste à trier */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_List_Sort (NDT_Root *, NDT_Index_Id); +NDT_Status ND_List_Sort( NDT_Root *, NDT_Index_Id); /*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/ @@ -257,40 +288,40 @@ NDT_Status ND_List_Sort (NDT_Root *, NDT_Index_Id); /*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/ -void ND_List_Check (NDT_Root *, NDT_Index_Id, int *, int *, FILE *); +void ND_List_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *); -void ND_List_Link_Check (NDT_Root *, NDT_Index_Id, int *, int *, FILE *); +void ND_List_Link_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *); -void ND_Value_Check (NDT_Root *, NDT_Index_Id, int *, int *, FILE *); +void ND_Value_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *); -void ND_Tree_Check (NDT_Root *, NDT_Index_Id, int *, int *, FILE *); +void ND_Tree_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *); -void ND_Tree_Link_Check (NDT_Root *, NDT_Index_Id, int *, int *, FILE *); +void ND_Tree_Link_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *); -NDT_Status ND_List_Recursive_Make (NDT_Node *, NDT_Root *, NDT_Index_Id); +NDT_Status ND_List_Recursive_Make( NDT_Node *, NDT_Root *, NDT_Index_Id); -NDT_Node * ND_Tree_Recursive_Make (long, long, NDT_Node *); +NDT_Node * ND_Tree_Recursive_Make( long, long, NDT_Node *); -void ND_Tree_Node_Recursive_Add( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Node **, long , NDT_Node *); +void ND_Tree_Node_Recursive_Add( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Node **, long , NDT_Node *); -NDT_Node * ND_Tree_Node_First_Recursive_Get (NDT_Node * Node); +NDT_Node * ND_Tree_Node_First_Recursive_Get( NDT_Node *); -NDT_Node * ND_Tree_Node_Last_Recursive_Get (NDT_Node * Node); +NDT_Node * ND_Tree_Node_Last_Recursive_Get( NDT_Node *); -NDT_Node * ND_Tree_Node_Recursive_Find (NDT_Node * Node, void * Value, va_list); +NDT_Node * ND_Tree_Node_Recursive_Find( NDT_Node *, void *, va_list); -NDT_Node * ND_Tree_Parent_Next_Recursive_Get (NDT_Node * Node); +NDT_Node * ND_Tree_Parent_Next_Recursive_Get( NDT_Node * Node); -NDT_Node * ND_Tree_Parent_Previous_Recursive_Get (NDT_Node * Node); +NDT_Node * ND_Tree_Parent_Previous_Recursive_Get( NDT_Node *); -void ND_Tree_Recursive_Print (NDT_Node * Node, long Depth, FILE *); +void ND_Tree_Recursive_Print( NDT_Node *, long, FILE *); -void ND_Tree_Link_Recursive_Check (NDT_Node * Node, int *, int *, FILE *); +void ND_Tree_Link_Recursive_Check( NDT_Node *Node, int *, int *, FILE *); -void * ND_Symbol_Find (const char *); +void * ND_Symbol_Find( const char *); -void ND_Error_Print (void); +void ND_Error_Print( void); -void ND_Signal_Trap (int); +void ND_Signal_Trap( int); -NDT_Status ND_Address_Check (void * Address); +NDT_Status ND_Address_Check(void *);