From af81f630c562ed37d08eba7ec9e99ba49a2ccb40 Mon Sep 17 00:00:00 2001 From: agibert Date: Sun, 6 Jun 2010 22:19:26 +0000 Subject: [PATCH] Update to 2.2.0-1. --- src/libnode/ReadMe.txt | 16 +- src/libnode/ReleaseNotes.txt | 25 +- src/libnode/ToDo.txt | 10 +- src/libnode/demo/nddemo0.c | 177 +++--- src/libnode/demo/nddemo0.dat | 10 +- src/libnode/doc/libnode.doc | Bin 0 -> 112640 bytes src/libnode/doc/man3/libnode.3 | 947 +++++++++++++++++++++++++++++++++ src/libnode/include/node.h | 388 +++++++++++++- src/libnode/src/libnode.c | 609 +++++++++++---------- src/libnode/src/libnode.h | 29 +- src/libnode/util/ndbench.c | 188 ++++--- src/libnode/util/ndbench.xls | Bin 0 -> 16896 bytes 12 files changed, 1913 insertions(+), 486 deletions(-) create mode 100644 src/libnode/doc/libnode.doc create mode 100644 src/libnode/doc/man3/libnode.3 create mode 100644 src/libnode/util/ndbench.xls diff --git a/src/libnode/ReadMe.txt b/src/libnode/ReadMe.txt index 5b2e6ac..e9e21ab 100644 --- a/src/libnode/ReadMe.txt +++ b/src/libnode/ReadMe.txt @@ -1,19 +1,19 @@ -# %RCSfile: ReadMe.txt,v % -# %Revision: 2.8 % -# %Name: libnode-2_1_0-1 % -# %Date: 2005/01/24 01:19:50 % -# %Author: agibert % +# $RCSfile: ReadMe.txt,v $ +# $Revision: 1.2 $ +# $Name: $ +# $Date: 2010/06/06 22:19:26 $ +# $Author: agibert $ -Welcome to LibNode 2.1.x ! +Welcome to LibNode 2.2.x ! This release of LibNode supports the following OS: - - Linux 2.2.x, 2.4.x and 2.6.x (tested on RedHat & Mandrake), + - Linux 2.2.x, 2.4.x and 2.6.x (tested on RedHat & Mandriva), - Solaris 2.6, - Windows NT4, 2000 and XP. @@ -41,4 +41,4 @@ Enjoy it! Your LibNode Team. arnaud@rx3.net -http://www.rx3.org/dvp/libnode +http://www.rx3.org/dvp/?dvp=libnode diff --git a/src/libnode/ReleaseNotes.txt b/src/libnode/ReleaseNotes.txt index d631beb..e094a74 100644 --- a/src/libnode/ReleaseNotes.txt +++ b/src/libnode/ReleaseNotes.txt @@ -1,13 +1,28 @@ -# %RCSfile: ReleaseNotes.txt,v % -# %Revision: 2.20 % -# %Name: libnode-2_1_0-1 % -# %Date: 2005/01/24 00:50:55 % -# %Author: agibert % +# $RCSfile: ReleaseNotes.txt,v $ +# $Revision: 1.2 $ +# $Name: $ +# $Date: 2010/06/06 22:19:27 $ +# $Author: agibert $ +------------------------------------------------------------------------------------------------------------------------------------ +LibNode V 2.2.0-1 - A. Gibert - 06/06/10 +------------------------------------------------------------------------------------------------------------------------------------ + +All: Add support C99 va_arg for curent gcc (4.4.1), + Add -fPIC flag in .c to .o makefile rule, +LibNode: Add ND_VA_* macros to help manager varargs, + Update Managers to use ND_VA_* macros, + Improve LibShMem support by restricting OpenStruct tracking on local DataStruct (Manager_Ptr != NULL), + Add example manager template in public node.h file, +NDDemo0: Add LibNode 2.2 support: Use ND_VA_* macros in manager, +NDBench: Add LibNode 2.2 support: Use ND_VA_* macros in manager. + + + ------------------------------------------------------------------------------------------------------------------------------------ LibNode V 2.1.0-1 - A. Gibert - 24/01/05 ------------------------------------------------------------------------------------------------------------------------------------ diff --git a/src/libnode/ToDo.txt b/src/libnode/ToDo.txt index e7ef09a..ec75fd7 100644 --- a/src/libnode/ToDo.txt +++ b/src/libnode/ToDo.txt @@ -1,8 +1,8 @@ -# %RCSfile: ToDo.txt,v % -# %Revision: 2.5 % -# %Name: libnode-2_1_0-1 % -# %Date: 2005/01/24 01:19:50 % -# %Author: agibert % +# $RCSfile: ToDo.txt,v $ +# $Revision: 1.2 $ +# $Name: $ +# $Date: 2010/06/06 22:19:27 $ +# $Author: agibert $ diff --git a/src/libnode/demo/nddemo0.c b/src/libnode/demo/nddemo0.c index 444ce55..d40d959 100644 --- a/src/libnode/demo/nddemo0.c +++ b/src/libnode/demo/nddemo0.c @@ -1,10 +1,10 @@ /*---------------------------------------------------------------------------------*/ -/* %RCSfile: nddemo0.c,v % */ +/* $RCSfile: nddemo0.c,v $ */ /*---------------------------------------------------------------------------------*/ -/* %Revision: 2.8 % */ -/* %Name: libnode-2_1_0-1 % */ -/* %Date: 2004/08/23 22:48:37 % */ -/* %Author: agibert % */ +/* $Revision: 1.2 $ */ +/* $Name: $ */ +/* $Date: 2010/06/06 22:20:16 $ */ +/* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/ @@ -64,7 +64,7 @@ typedef struct Demo_Value /* Prototypes */ /*---------------------------------------------------------------------------------*/ -NDT_Status Demo_DS_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); +NDT_Status Demo_DS_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *); void DataStruct_Load( NDT_Root *, FILE *); void DataStruct_Load( NDT_Root *, FILE *); void Demo( char *, short); @@ -80,7 +80,7 @@ int main( int, char **); /* */ /*---------------------------------------------------------------------------------*/ -NDT_Status Demo_DS_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) +NDT_Status Demo_DS_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr) { NDT_Command_Name Command_Name; @@ -89,12 +89,12 @@ NDT_Status Demo_DS_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_No { case NDD_CMD_MANAGER_VERSION: { - NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); + ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *); Command_Name = "NDD_CMD_MANAGER_VERSION"; - *Version_Name_Ptr = "%Revision: 2.8 % %Name: libnode-2_1_0-1 % %Date: 2004/08/23 22:48:37 % %Author: agibert %"; + *Version_Name_Ptr = "$Revision: 1.2 $ $Name: $ $Date: 2010/06/06 22:20:16 $ $Author: agibert $"; return( NDS_OK); } @@ -102,15 +102,15 @@ NDT_Status Demo_DS_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_No 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 *); + ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); + ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); + ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, 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); - Demo_Value *Value_ptr = (Demo_Value *)va_arg( Args, Demo_Value *); + ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); + ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); + ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, Demo_Value *); Command_Name = "NDD_CMD_INDEX_GET"; @@ -159,12 +159,15 @@ NDT_Status Demo_DS_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_No 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, ...); + ND_VA_ARG_GET( Value_Ptr_Ptr, *Args_Ptr, void **); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ - Demo_Value **Value_Ptr_Ptr = va_arg( Args, Demo_Value **); + ND_VA_ARG_GET( Value_Ptr_Ptr, *Args_Ptr, Demo_Value **); Command_Name = "NDD_CMD_VALUE_ALLOC"; @@ -187,12 +190,15 @@ NDT_Status Demo_DS_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_No 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ - Demo_Value *Value_Ptr = (Demo_Value *)va_arg( Args, Demo_Value *); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, Demo_Value *); Command_Name = "NDD_CMD_VALUE_FREE"; @@ -205,14 +211,17 @@ NDT_Status Demo_DS_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_No 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, ...); + ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, void *); + ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ - Demo_Value *Value1_Ptr = va_arg( Args, Demo_Value *); - Demo_Value *Value2_Ptr = va_arg( Args, Demo_Value *); + ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, Demo_Value *); + ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, Demo_Value *); Command_Name = "NDD_CMD_VALUE_COMP"; @@ -302,12 +311,17 @@ NDT_Status Demo_DS_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_No 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ + Command_Name = "NDD_CMD_VALUE_ADD"; return( NDS_OK); @@ -316,38 +330,56 @@ NDT_Status Demo_DS_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_No 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( 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); - 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, ...); + /* + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - 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); + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); - Demo_Value *Value_Ptr = Node_Ptr->Value; + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_OPEN( user_args, lib_args); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + ND_VA_LIST_CLOSE( lib_args); + */ + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); + + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); + + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_CLOSE( lib_args); + + + Demo_Value *Value_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_VALUE_PRINT"; @@ -361,18 +393,25 @@ NDT_Status Demo_DS_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_No 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); - 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, ...); + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - void *Value_Ptr = Node_Ptr->Value; + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); + + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_OPEN( user_args, lib_args); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + ND_VA_LIST_CLOSE( lib_args); */ + Command_Name = "NDD_CMD_INFO_PRINT"; return( NDS_OK); @@ -409,7 +448,7 @@ void DataStruct_Load( NDT_Root *ds_ptr, FILE *demo_file) while( !feof( demo_file)) { str = fgets( input_string, STRING_SIZE, demo_file); - if( ( (const int)str != EOF) && ( str != NULL)) + if( str != NULL) { if( strlen( input_string) >= STRING_LEN) { diff --git a/src/libnode/demo/nddemo0.dat b/src/libnode/demo/nddemo0.dat index 07ddfe8..2159449 100644 --- a/src/libnode/demo/nddemo0.dat +++ b/src/libnode/demo/nddemo0.dat @@ -1,10 +1,10 @@ #--------------------------------------------------------------------------------- -# %RCSfile: nddemo0.dat,v % +# $RCSfile: nddemo0.dat,v $ #--------------------------------------------------------------------------------- -# %Revision: 2.1 % -# %Name: libnode-2_1_0-1 % -# %Date: 2003/07/16 00:17:02 % -# %Author: agibert % +# $Revision: 1.2 $ +# $Name: $ +# $Date: 2010/06/06 22:20:17 $ +# $Author: agibert $ #--------------------------------------------------------------------------------- ggg 1 xxxxxx example aaa 7 x this diff --git a/src/libnode/doc/libnode.doc b/src/libnode/doc/libnode.doc new file mode 100644 index 0000000000000000000000000000000000000000..92a1947ade9c9d8a5d8ed2c5d586f81bdc9fc748 GIT binary patch literal 112640 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
Swz|yDv2$~CH(}&hJYS=XoEhVH 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 +.LP +.BI "NDT_Status ND_Library_Open ( int " Debug_Mode " );" +.LP +.BI "NDT_Status ND_Library_Close ( void );" +.LP +.BI "NDT_Status ND_Library_Stderr_Set ( FILE * " Out " );" +.LP +.BI "NDT_Status ND_DataStruct_Open ( NDT_Root ** " Root ", NDT_DataStruct_Type " Type ", const char * " Allocator ", const char * " Desallocator ", void * " User " );" +.LP +.BI "NDT_Status ND_DataStruct_Close ( NDT_Root * " Root " );" +.LP +.BI "NDT_Status ND_DataStruct_Reorg ( NDT_Root * " Root " );" +.LP +.BI "NDT_Status ND_DataStruct_Traverse ( NDT_Root * " Root ", NDT_Command, void * " Command ", void * " Data " );" +.LP +.BI "NDT_Status ND_DataStruct_Convert ( NDT_Root * " Root ", ND_Conversion_Type " Target_Type " );" +.LP +.BI "NDT_Status ND_DataStruct_Info_Print ( NDT_Root * " Root ", FILE * " Out " );" +.LP +.BI "NDT_Status ND_DataStruct_Print ( NDT_Root * " Root ", FILE * " Out " );" +.LP +.BI "NDT_Status ND_DataStruct_Check ( NDT_Root * " Root ", int * " Nb_Detected ", int * " Nb_Corrected " ,FILE * " Out " );" +.LP +.BI "NDT_Status ND_DataStruct_Dump ( NDT_Root * " Root ", FILE * " Out " );" +.LP +.BI "NDT_Status ND_Node_Root_Get ( NDT_Root ** " Root ", NDT_Node * " Node " );" +.LP +.BI "NDT_Status ND_Node_First_Get ( NDT_Root * " Root ", NDT_Node ** " Node " );" +.LP +.BI "NDT_Status ND_Node_Last_Get ( NDT_Root * " Root ", NDT_Node ** " Node " );" +.LP +.BI "NDT_Status ND_Node_Next_Get ( NDT_Node * " Node ", NDT_Node ** " Next_Node " );" +.LP +.BI "NDT_Status ND_Node_Previous_Get ( NDT_Node * " Node ", NDT_Node ** " Prev_Node " );" +.LP +.BI "NDT_Status ND_Node_Add ( NDT_Root * " Root ", NDT_Node * " Node " );" +.LP +.BI "NDT_Status ND_Node_Remove ( NDT_Node * " Node " );" +.LP +.BI "NDT_Status ND_Node_Find ( NDT_Root * " Root ", NDT_Node ** " Node ",void * " Value " , void * " Data " );" +.LP +.BI "NDT_Status ND_Value_Alloc ( NDT_Root * " Root ", void ** " Value ", ... );" +.LP +.BI "NDT_Status ND_Value_Add ( NDT_Root * " Root ", void * " Value " );" +.LP +.BI "NDT_Status ND_Value_Remove ( NDT_Root * " Root ", void * " Reference_Value " , void ** " Removed_Value " );" +.LP +.BI "NDT_Status ND_Value_Free ( NDT_Root * " Root ", void * " Value " );" +.LP +.BI "NDT_Status ND_Manager_Exec (const char * " Function_Name ", ...)" +.LP +.BI "NDT_Status ND_Allocator_Exec (const char * " Function_Name ", void ** " Ptr ", size_t " Size ", void * " Data " );" +.LP +.BI "NDT_Status ND_Desallocator_Exec (const char * " Function_Name ", void * " Ptr ", void * " Data " );" +.LP +.SH DESCRIPTION +.LP +La bibliotheque LIBNODE implemente deux types de structure de donnees a base de noeuds : +.LP +.RS 3 +- liste chainee +.LP +- arbre binaire +.RS -3 +.LP +Une structure de donnees est composee d'une racine ( voir le type +.B NDT_Root +) et de zero, un ou plusieurs noeuds (voir le type +.B NDT_Node +). +.LP +Fondamentalement, seul le chainage entre les noeuds distingue les differents types de structure implementes dans cette librairie. +.LP +La librairie LIBNODE implemente les fonctions minimales pour ce type de structure. +Elle pourra bien entendu etre enrichie suite aux remarques des utilisateurs. +.LP +.SH TYPES +.LP +La librairie LIBNODE definit les types suivants : +.LP +.BI NDT_Root +.LP +.RS 3 +Designe le type d'une racine de structure de donnees +.LP +Il s'agit d'une structure qui contient toutes les informations statistiques de la structure de donnees sous-jacente : +.LP +.RS 3 +- nombre de noeuds ( +.B ND_Node_Number +) +.LP +- profondeur minimum ( +.B Min_Depth +) (pour les arbres) +.LP +- profondeur maximum ( +.B Max_Depth +) (pour les arbres) +.LP +- nombre de reequilibrages ( +.B Nb_Equ +) (pour les arbres) +.RS -3 +.LP +La structure racine pointe sur les noeuds de tete ( +.B Head +) et de queue ( +.B Queue +) de la structure de donnees. +Pour une liste chainee, le noeud de tete est le premier noeud de la liste et le noeud de queue est le dernier noeud de la liste. +Pour un arbre binaire, le noeud de tete et le noeud de queue correpondent tous deux au meme noeud racine de l'arbre. +.LP +La gestion des arbres binaires prend en compte un reequilibrage automatique. +La structure racine conserve pour cela la taille de la plus grande branche de l'arbre ( +.B Max_Depth +) ainsi que celle de la plus courte ( +.B Min_Depth +). +Pour un arbre auto-equilibre, le depassement d'un seuil ( +.B Max_Dif +) provoque immediatement son reequilibrage. +.LP +La racine d'une structure reference enfin les fonctions suivantes par leur nom : +.LP +.RS 3 +- +.B Manager +: fonction qui implemente les commandes specifiques a realiser sur les valeurs, notamment : +.RS 3 +.LP +- la creation d'une valeur +.LP +- la suppression d'une valeur +.LP +- l'affichage d'une valeur +.LP +- la comparaison de deux valeurs +.RS -3 +.LP +- +.B Allocator +: fonction qui realise l'allocation de memoire pour la structure +.LP +- +.B Desallocator +: fonction qui realise la desallocation de memoire pour la structure +.LP +.RS -3 +.I NB +: une racine contient un pointeur librement utilisable par l'utilisateur ( +.B User +). +.LP +.RS -3 +.B NDT_DataStruct_Type +.LP +.RS 3 +Ce type definit sur un entier long le type de chainage de la structure de donnees : +.LP +.RS 3 +- +.B NDD_DS_LIST +: liste chainee +.LP +- +.B NDD_DS_TREE +: arbre binaire +.RS -3 +.LP +et son mode de gestion : +.RS 3 +.LP +- +.B NDD_MN_FIFO +(ou +.B NDD_MN_LILO +) : principe de la file d'attente (First In First Out) +.LP +- +.B NDD_MN_FILO +(ou +.B NDD_MN_LIFO +) : principe de la pile (First In Last Out) +.LP +- +.B NDD_MN_ORDERED +: ordonnancement des valeurs (liste triee). +Losque deux noeuds ont la meme valeur, ils seront ordonnes dans l'ordre chronologique d'insertion. +.LP +Toutefois, l'utilisateur pourra combiner par addition binaire les types +.B NDD_MN_ORDERED +et +.B NDD_MN_FILO +afin que deux noeuds de meme valeur soient ordonnes dans l'ordre inverse. +.LP +- +.B NDD_MN_AUTO_EQU +: auto-equilibre (arbre) +.RS -3 +.LP +Les valeurs NDD_DS* et NDD_MN* peuvent etre utilisees de maniere combinee par addition binaire. +.LP +.I Exemple +: +.LP +Mon_Type = +.B NDD_DS_LIST +| +.B NDD_MN_ORDERED +; +.LP +Mon_Type = +.B NDD_DS_TREE +| +.B NDD_MN_AUTO_EQU +; +.LP +Des valeurs "masque" permettent de ne recuperer que l'une des deux parties du type : +.LP +.RS 3 +- +.B NDD_DS_MSK +: masque sur le type de chainage +.LP +- +.B NDD_MN_MSK +: masque sur le mode de gestion +.LP +.RS -3 +.I Exemple +: +.LP +(Mon_Type & +.B NDD_DS_MSK +) renverra la valeur +.B NDD_DS_LIST +ou +.B NDD_DS_TREE +. +.LP +(Mon_Type & +.B NDD_MN_MSK +) renverra l'une des valeurs +.B NDD_MN_FILO +, +.B NDD_MN_FIFO +, +.B NDD_MN_ORDERED +ou +.B NDD_MN_AUTO_EQU +. +.LP +.RS -3 +.BI NDT_Node +.LP +.RS 3 +Designe le type d'un noeud +.LP +Il s'agit d'une structure qui permet aux noeuds d'etre relies les uns aux autres : +.LP +.RS 3 +- pointeur sur le noeud droite ( +.B Right +) +.LP +- pointeur sur le noeud gauche ( +.B Left +) +.RS -3 +.LP +Pour une structure de type arbre, chaque noeud pointe aussi sur son noeud pere ( +.B Parent +). +Chaque noeud possede enfin un pointeur sur sa structure racine ( +.B Root +). +.LP +A chaque noeud sera associee une valeur dont l'utilisateur de la librairie devra lui meme definir le type. +.RS -3 +.LP +.BI NDT_Value +.LP +.RS 3 +Designe le type d'une valeur attachee a un noeud. Ce type sera surcharge par celui defini par l'utilisateur. +.LP +.RS -3 +.BI NDT_Manager +.LP +.RS 3 +Designe le type d'une fonction manager. +.LP +Une fonction manager est attachee a la racine de la structure via son nom et permet d'executer des commandes (voir +.B NDT_Command +) specifiques sur la structure ou sur ses valeurs. +.LP +L'implementation des ces commandes est a definir par l'utilisateur lui-meme. +.LP +Le premier argument d'une fonction manager correspond toujours au type de la commande a executer. +.LP +Les autres arguments dependent bien evidemment de la commande a executer. +.LP +Une fonction manager doit etre executee via la fonction +.B NDT_Manager_Exec +(voir FONCTIONS). +.LP +.RS -3 +.BI NDT_Command +.LP +.RS 3 +Designe le type d'une commande pouvant etre executee par le manager : +.RS 3 +.LP +- +.B NDD_CMD_COMP_VALUE +: comparaison de valeurs +.LP +- +.B NDD_CMD_MAKE_VALUE +: creation de valeur +.LP +- +.B NDD_CMD_PRINT_VALUE +: affichage de valeur +.LP +- +.B NDD_CMD_DELETE_VALUE +: suppression de valeur +.LP +- +.B NDD_CMD_PRINT_INFO +: affichage des informations de la racine +.RS -3 +.LP +.I NB +Toutes ces commandes ne doivent pas necessairement etre implementees par l'utilisateur. A priori, seule la commande permettant de detruire une valeur est obligatoire. +De nouvelles commandes pourront aussi etre definies par l'utilisateur, sous reserve qu'elles soient implementee par la fonction manager. +.RS -3 +.LP +.BI NDT_Allocator +.LP +.RS 3 +Designe le type d'une fonction d'allocation memoire. +.LP +Une fonction d'allocation est attachee a la racine de la structure par son nom et permet de d'allouer de la memoire pour le stockage de la structure (racine et noeuds). +.LP +Par defaut, une structure de donnees definira la fonction malloc() comme fonction d'allocation. +.LP +.I NB +: une fonction d'allocation devra etre executee via la fonction +.B NDT_Allocator_Exec +(voir FONCTIONS). +.LP +.RS -3 +.BI NDT_Desallocator +.LP +.RS 3 +Designe le type d'une fonction de desallocation memoire. +.LP +Une fonction de desallocation est attachee a la racine de la structure par son nom et permet de liberer la memoire allouee pour le stockage de la structure. +.LP +Par defaut, une structure de donnees definira la fonction free() comme fonction de desallocation. +.LP +.I NB +: une fonction de desallocation devra etre executee via la fonction +.B NDT_Desallocator_Exec +(voir FONCTIONS). +.LP +.RS -3 +.SH FONCTIONS +.BI "ND_Library_Open ( int " Debug_Mode " )" +.RS 3 +.LP +Cette fonction permet d'initialiser les eventuelles ressources de la librairie. +Elle doit etre systematiquement appelee au debut de chaque programme utilisant la librairie. +.LP +L'argument +.I Debug_Mode +(TRUE ou FALSE) permet d'utiliser la librairie en mode bavard ou non, ce qui sigifie que tous les messages d'erreur seront affiches par defaut sur la sortie standard. +.LP +.RS -3 +.BI "ND_Library_Close ( void )" +.RS 3 +.LP +Cette fonction permet de fermer les eventuelles ressources de la librairie. +Elle doit etre systematiquement appelee a la fin de chaque programme utilisant la librairie. +.LP +.RS -3 +.BI "NDT_Status ND_Library_Stderr_Set ( FILE * " Out " );" +.LP +.RS 3 +Cette fonction permet de definir +.I Out +comme la sortie standard des messages d'erreur de la librarie. +.RS -3 +.LP +.BI "NDT_Status ND_DataStruct_Open ( NDT_Root ** " Root ", NDT_DataStruct_Type " Type ", const char * " Allocator ", const char * " Desallocator ", void * " User " , int " Own_Value " );" +.RS 3 +.LP +Cette fonction permet de creer une structure de donnees. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (Out) +.I Root +: l'adresse du pointeur sur la racine de la nouvelle structure de donnees +.LP +* (In) +.I Type +: le type de la nouvelle structure de donnees +.LP +* (In) +.I Allocator +: le nom de la fonction d'allocation memoire (fonction de type +.B NDT_Allocator +) associee a la nouvelle structure de donnees. +Si cet argument est positionne a NULL, alors la fonction d'allocation locale malloc() sera utilisee par defaut. +.LP +* (In) +.I Desallocator +: le nom de la fonction de desallocation memoire (fonction de type +.B NDT_Desallocator +) associee a la nouvelle structure de donnees. +Si cet argument est positionne a NULL, alors la fonction de desallocation locale free() sera utilisee par defaut. +.LP +* (In) +.I User +: un pointeur de donnees qui sera systematiquement passe au manager pour l'allocation et la desallocation. +.LP +* (In) +.I Own_Value +: valeur TRUE ou FALSE indiquant si la structure est proprietaire de ses valeurs. +.LP +.I NB +: si une structure est proprietaire de ses valeurs, alors sa destruction provoque aussi la desallocation des valeurs rattachees a ses noeuds +.LP +.RS -3 +.RS -3 +.BI "NDT_Status ND_DataStruct_Close ( NDT_Root * " Root " );" +.RS 3 +.LP +Cette fonction permet de detruire une structure de donnees (desallocation des ressources). +.LP +L'argument +.I Root +est un pointeur sur la racine de la structure de donnees a detruire. +.LP +.I NB +: les valeurs de la structure seront desallouees en meme temps que leur noeud selon que la structure est proprietaire ou non de ses valeurs. +.LP +.RS -3 +.BI "NDT_Status ND_DataStruct_Reorg ( NDT_Root * " Root " );" +.RS 3 +.LP +Cette fonction permet de reorganiser les donnees d'une structure (tri pour une liste, reequilibrage pour un arbre). +.LP +L'argument +.I Root +est un pointeur sur la racine de la structure de donnees a reorganiser. +.LP +.RS -3 +.BI "NDT_Status ND_DataStruct_Traverse ( NDT_Root * " Root ", NDT_Command, void * " Command ", void * " Data " );" +.RS 3 +.LP +Cette fonction permet de parcourir tous les noeuds d'une structure de donnees avec execution d'une commande sur chacun d'eux. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees a parcourir. +.LP +* (In) +.I Command +: la commande a executer sur chaque noeud traverse +.LP +* (In) +.I Data +: un pointeur de donnees propre a la commande +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_DataStruct_Convert ( NDT_Root * " Root ", ND_Conversion_Type " Target_Type " );" +.RS 3 +.LP +Cette fonction permet de convertir une structure de donnees d'un type en un autre. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees a convertir. +.LP +* (In) +.I Target_Type +: le type cible de la structure +.LP +.RS -3 +.RS -3 +.BI "NDT_Status ND_DataStruct_Print ( NDT_Root * " Root ", FILE * " Out " );" +.LP +.RS 3 +Cette fonction permet d'afficher toutes les valeurs des noeuds d'une structure de donnees. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees a afficher. +.LP +* (In) +.I Out +: un pointeur sur le flux de sortie +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_DataStruct_Info_Print ( NDT_Root * " Root ", FILE * " Out " );" +.LP +.RS 3 +Cette fonction permet d'afficher des informations concernant une structure de donnees. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees +.LP +* (In) +.I Out +: un pointeur sur le flux de sortie +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_DataStruct_Check ( NDT_Root * " Root ", int * " Nb_Detected ", int * " Nb_Corrected " ,FILE * " Out " );" +.LP +.RS 3 +Cette fonction permet de verifier et de corriger des incoherences contenues dans une structure de donnees. +Elle verifie notamment les liens entre les noeuds, supprime les noeuds sans valeur ou ceux dont les valeurs ne sont pas accessibles et met a jour les informations statistiques de la racine. +Un rapport de toutes les erreurs detectees ou corrigees est affiche. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees a verifier. +.LP +* (Out) +.I Nb_Detected +: un pointeur sur le nombre d'erreurs detectees +.LP +* (Out) +.I Nb_Corrected +: un pointeur sur le nombre d'erreurs corrigees +.LP +* (In) +.I Out +: un pointeur sur le flux de sortie du rapport +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_DataStruct_Dump ( NDT_Root * " Root ", FILE * " Out " );" +.LP +.RS 3 +Cette fonction permet d'afficher toutes les informations de la structure (racine et contenu). +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees a afficher. +.LP +* (In) +.I Out +: un pointeur sur le flux de sortie +.RS -3 +.LP +.I NB +: cette fonction a ete implementee dans une optique de deboggage. +.LP +.RS -3 +.BI "NDT_Status ND_Node_Root_Get ( NDT_Root ** " Root ", NDT_Node * " Node " );" +.LP +.RS 3 +Cette fonction permet de recuperer la racine d'une structure a partir d'un de ses noeuds. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (Out) +.I Root +: l'adresse d'un pointeur sur la racine a recuperer +.LP +* (In) +.I Node +: un pointeur sur un noeud +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_Node_First_Get ( NDT_Root * " Root ", NDT_Node ** " Node " );" +.LP +.RS 3 +Cette fonction permet de recuperer le premier noeud d'une structure. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure +.LP +* (Out) +.I Node +: l'adresse d'un pointeur sur le premier noeud a recuperer +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_Node_Last_Get ( NDT_Root * " Root ", NDT_Node ** " Node " );" +.LP +.RS 3 +Cette fonction permet de recuperer le dernier noeud d'une structure. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure +.LP +* (Out) +.I Node +: un pointeur sur le dernier noeud a recuperer +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_Node_Next_Get ( NDT_Node * " Node ", NDT_Node ** " Next_Node " );" +.LP +.RS 3 +Cette fonction permet de recuperer le noeud qui suit immediatement un noeud particulier. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Node +: un pointeur sur le noeud de reference +.LP +* (Out) +.I Next_Node +: l'adresse d'un pointeur sur le noeud qui suit le noeud de reference +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_Node_Previous_Get ( NDT_Node * " Node ", NDT_Node ** " Prev_Node " );" +.LP +.RS 3 +Cette fonction permet de recuperer le noeud qui precede immediatement un noeud particulier. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Node +: un pointeur sur le noeud de reference +.LP +* (Out) +.I Prev_Node +: l'adresse d'un pointeur sur le noeud qui precede le noeud de reference +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_Node_Add ( NDT_Root * " Root ", NDT_Node * " Node " );" +.LP +.RS 3 +Cette fonction permet d'ajouter un noeud a une structure. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees +.LP +* (In) +.I Node +: un pointeur sur le noeud a ajouter +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_Node_Remove ( NDT_Node * " Node " );" +.RS 3 +.LP +Cette fonction permet de supprimer le noeud d'une structure de donnees. +.LP +L'argument +.I Node +est un pointeur sur le noeud a supprimer +.LP +.I NB +: le noeud supprime n'est pas detruit mais simplement detache de la structure +.LP +.RS -3 +.BI "NDT_Status ND_Node_Find ( NDT_Root * " Root ", NDT_Node ** " Node ", void * " Value " , void * " Data " );" +.LP +.RS 3 +Cette fonction permet de rechercher dans une structure de donnees le premier noeud correspondant a une valeur. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees +.LP +* (Out) +.I Node +: l'adresse d'un pointeur sur le noeud resultat +.LP +* (In) +.I Value +: un pointeur sur la valeur a rechercher +.LP +* (In) +.I Data +: un pointeur de donnees qui sera passe a la fonction manager pour la recherche +.RS -3 +.LP +.RS -3 +.LP +.BI "NDT_Status ND_Value_Alloc ( NDT_Root * " Root ", void ** " Value ", ... );" +.LP +.RS 3 +Cette fonction permet d'allouer une valeur pour une structure de donnees. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees +.LP +* (Out) +.I Value +: l'adresse d'un pointeur sur la valeur a allouer +.LP +* (In) +.I ... +: des arguments supplementaires pour l'allocation de la valeur +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_Value_Add ( NDT_Root * " Root ", void * " Value " );" +.LP +.RS 3 +Cette fonction permet d'ajouter une valeur a une structure de donnees. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees +.LP +* (In) +.I Value +: un pointeur sur la valeur a ajouter +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_Value_Remove ( NDT_Root * " Root ", void * " Reference_Value " , void ** " Removed_Value " );" +.RS 3 +.LP +Cette fonction permet de supprimer le premier noeud correspondant a une valeur. +.LP +Elle doit recevoir les arguments suivants : +.RS 3 +.LP +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees +.LP +* (In) +.I Reference_Value +: un pointeur sur la valeur de reference +.LP +* (Out) +.I Removed_Value +: l'adresse d'un pointeur sur la valeur du noeud supprime +.LP +.RS -3 +.I NB +: la suppression d'un noeud implique son retrait de la structure et sa desallocation. +.LP +Si la structure contient plusieurs fois la valeur, seul le premier noeud correspondant a cette valeur est detruit. +.LP +.RS -3 +.BI "NDT_Status ND_Value_Free ( NDT_Root * " Root ", void * " Value " );" +.LP +.RS 3 +Cette fonction permet de desallouer une valeur faisant partie d'une structure de donnees. +.LP +Elle doit recevoir les arguments suivants : +.LP +.RS 3 +* (In) +.I Root +: un pointeur sur la racine de la structure de donnees +.LP +* (In) +.I Value +: un pointeur sur la valeur a desallouer +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_Manager_Exec (const char * " Function_Name ", ...)" +.LP +.RS 3 +Cette fonction permet d'executer une fonction manager a partir de son nom. +.LP +L'argument +.I Function_Name +est le nom de la fonction manager (fonction de type +.B NDT_Manager +), suivi de tous les arguments contextuels necessaires a son execution. +.LP +.RS -3 +.BI "NDT_Status ND_Allocator_Exec (const char * " Function_Name ", void ** " Ptr ", size_t " Size ", void * " Data " );" +.LP +.RS 3 +Cette fonction permet d'executer une fonction d'allocation a partir de son nom. +.LP +Elle doit recevoir les arguments suivants : +.RS 3 +.LP +* (In) +.I Function_Name +: le nom de la fonction d'allocation (fonction de type +.B NDT_Allocator +) +.LP +* (Out) +.I Ptr +: l'adresse d'un pointeur sur la zone a allouer +.LP +* (In) +.I Size +: la taille a allouer +.LP +* (In) +.I Data +: un pointeur de donneees utile a la fonction d'allocation +.RS -3 +.LP +.RS -3 +.BI "NDT_Status ND_Desallocator_Exec (const char * " Function_Name ", void * " Ptr ", void * " Data " );" +.LP +.RS 3 +Cette fonction permet d'executer une fonction de desallocation a partir de son nom. +.LP +Elle doit recevoir les arguments suivants : +.RS 3 +.LP +* (In) +.I Function_Name +: le nom de la fonction de desallocation (fonction de type +.B NDT_Desallocator +) +.LP +* (In) +.I Ptr +: l'adresse de la zone memoire a desallouer +.LP +* (In) +.I Data +: un pointeur de donneees utile a la fonction de desallocation +.RS -3 +.LP +.RS -3 +.SH CODES RETOUR +.LP +Toutes les fonctions constituant l'API de la librairie LIBND retournent un code de type +.B NDT_Status +: +.LP +.RS 3 +- +.B NDS_OK +: la fonction s'est correctement executee et a produit un resultat +.LP +- +.B NDS_KO +: la fonction s'est correctement executee mais n'a pas produit de resultat +.LP +- +.B NDS_ERRAPI +: la fonction a ete appelee avec des arguments de valeur incorrecte +.LP +- +.B NDS_ERRMEM +: la fonction ne s'est pas correctement executee pour un probleme d'allocation memoire +.RS -3 +.LP +La macro +.B ND_ERROR(rc) +permet de tester si un code retour correspond a une erreur. +.LP +En cas d'erreur, la variable ND_Error_Msg contient un message du type : +.LP +.RS 3 +Error : +.RS -3 +.LP +Lorsque le manager est appele avec la commande +.B NDD_CMD_COMP_VALUE +(comparaison de valeurs), l'une des trois valeurs suivantes est retournee : +.RS 3 +.LP +- +.B NDS_EQUAL +.LP +- +.B NDS_LOWER +.LP +- +.B NDS_GREATER +.LP +.RS -3 +.LP +.SH VOIR AUSSI +.B libdatastr +(3) diff --git a/src/libnode/include/node.h b/src/libnode/include/node.h index 2d83cda..7f47dc4 100644 --- a/src/libnode/include/node.h +++ b/src/libnode/include/node.h @@ -1,19 +1,10 @@ -/*----------------------------------------------------------------------------*/ -/* $Workfile: node.h $ */ -/*----------------------------------------------------------------------------*/ -/* $Author: agibert $ */ -/* $Date: 2008/11/12 02:25:23 $ */ -/* $Revision: 1.1 $ */ -/* $Label: $ */ -/*----------------------------------------------------------------------------*/ - /*---------------------------------------------------------------------------------*/ -/* %RCSfile: node.h,v % */ +/* $RCSfile: node.h,v $ */ /*---------------------------------------------------------------------------------*/ -/* %Revision: 2.12 % */ -/* %Name: libnode-2_1_0-1 % */ -/* %Date: 2005/01/20 00:00:25 % */ -/* %Author: agibert % */ +/* $Revision: 1.2 $ */ +/* $Name: $ */ +/* $Date: 2010/06/06 22:20:17 $ */ +/* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/ @@ -160,6 +151,349 @@ typedef int NDT_Index_Type; +/* Manager Template */ + +// NDT_Status ND_Example_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr) +// { +// NDT_Command_Name Command_Name; +// +// +// switch( Command) +// { +// case NDD_CMD_MANAGER_VERSION: +// { +// ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *); +// +// +// Command_Name = "NDD_CMD_MANAGER_VERSION"; +// +// *Version_Name_Ptr = "$Revision: 1.2 $ $Name: $ $Date: 2010/06/06 22:20:17 $ $Author: agibert $"; +// +// return( NDS_OK); +// } +// +// case NDD_CMD_INDEX_GET: +// { +// /* +// ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); +// ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); +// ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); +// ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); +// */ +// ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); +// ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); +// ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); +// ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); +// +// +// Command_Name = "NDD_CMD_INDEX_GET"; +// +// switch(Cmd) +// { +// /* +// 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; +// } +// } +// +// return( NDS_OK); +// } +// +// case NDD_CMD_VALUE_ALLOC: +// { +// /* +// ND_VA_ARG_GET( Value_Ptr_Ptr, *Args_Ptr, void **); +// +// ND_VA_LIST_OPEN( user_args, *Args_Ptr); +// +// ND_VA_ARG_GET( user_data, user_args, user_type); +// ND_VA_ARG_GET( ..., user_args, ...); +// +// ND_VA_LIST_CLOSE( user_args); +// */ +// +// +// Command_Name = "NDD_CMD_VALUE_ALLOC"; +// +// /* +// if( ( *Value_Ptr_Ptr = (void *)malloc( sizeof(void))) == NULL) +// { +// return(NDS_ERRMEM); +// } +// else +// { +// ... +// +// return( NDS_OK); +// } +// */ +// } +// +// case NDD_CMD_VALUE_FREE: +// { +// /* +// ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); +// +// ND_VA_LIST_OPEN( user_args, *Args_Ptr); +// +// ND_VA_ARG_GET( user_data, user_args, user_type); +// ND_VA_ARG_GET( ..., user_args, ...); +// +// ND_VA_LIST_CLOSE( user_args); +// */ +// +// +// Command_Name = "NDD_CMD_VALUE_FREE"; +// +// /* +// free( Value_Ptr); +// +// return( NDS_OK); +// */ +// } +// +// case NDD_CMD_VALUE_COMP: +// { +// /* +// ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, void *); +// ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, void *); +// +// ND_VA_LIST_OPEN( user_args, *Args_Ptr); +// +// ND_VA_ARG_GET( user_data, user_args, user_type); +// ND_VA_ARG_GET( ..., user_args, ...); +// +// ND_VA_LIST_CLOSE( 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: +// { +// /* +// ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); +// +// ND_VA_LIST_OPEN( user_args, *Args_Ptr); +// +// ND_VA_ARG_GET( user_data, user_args, user_type); +// ND_VA_ARG_GET( ..., user_args, ...); +// +// ND_VA_LIST_CLOSE( user_args); +// */ +// +// +// Command_Name = "NDD_CMD_VALUE_ADD"; +// +// /* +// return( NDS_OK); +// */ +// } +// +// case NDD_CMD_VALUE_REMOVE: +// { +// /* +// ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); +// +// ND_VA_LIST_OPEN( user_args, *Args_Ptr); +// +// ND_VA_ARG_GET( user_data, user_args, user_type); +// ND_VA_ARG_GET( ..., user_args, ...); +// +// ND_VA_LIST_CLOSE( user_args); +// */ +// +// +// Command_Name = "NDD_CMD_VALUE_REMOVE"; +// /* +// return( NDS_OK); +// */ +// } +// +// case NDD_CMD_VALUE_PRINT: +// { +// /* +// ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); +// +// ND_VA_LIST_OPEN( lib_args, *Args_Ptr); +// +// ND_VA_ARG_GET( Out, lib_args, FILE *); +// ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); +// ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); +// ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); +// +// ND_VA_LIST_OPEN( user_args, lib_args); +// +// ND_VA_ARG_GET( user_data, user_args, user_type); +// ND_VA_ARG_GET( ..., user_args, ...); +// +// ND_VA_LIST_CLOSE( user_args); +// ND_VA_LIST_CLOSE( lib_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: +// { +// /* +// ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); +// +// ND_VA_LIST_OPEN( lib_args, *Args_Ptr); +// +// ND_VA_ARG_GET( Out, lib_args, FILE *); +// ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); +// ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); +// ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); +// +// ND_VA_LIST_OPEN( user_args, lib_args); +// +// ND_VA_ARG_GET( user_data, user_args, user_type); +// ND_VA_ARG_GET( ..., user_args, ...); +// +// ND_VA_LIST_CLOSE( user_args); +// ND_VA_LIST_CLOSE( lib_args); +// */ +// +// +// Command_Name = "NDD_CMD_INFO_PRINT"; +// +// /* +// return( NDS_OK); +// */ +// } +// +// case NDD_CMD_USER_TRAVERSE: +// { +// /* +// ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); +// +// ND_VA_LIST_OPEN( user_args, *Args_Ptr); +// +// ND_VA_ARG_GET( user_data, user_args, user_type); +// ND_VA_ARG_GET( ..., user_args, ...); +// +// ND_VA_LIST_CLOSE( 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); +// } + + + +/* Var Args Manager Macros */ + +#define ND_VA_LIST_OPEN( VA_List_Target, VA_List_Source) va_list VA_List_Target; va_copy( VA_List_Target, *va_arg( VA_List_Source, va_list *)) +#define ND_VA_LIST_CLOSE( VA_List) va_end( VA_List) +#define ND_VA_ARG_GET( Arg, VA_List, Type) Type Arg = va_arg( VA_List, Type) + + + /* Commandes du manager */ typedef int NDT_Command; @@ -225,7 +559,7 @@ struct NDT_Node; typedef char *NDT_Manager_Name; -typedef NDT_Status NDT_Manager( struct NDT_Root *, NDT_Index_Id, struct NDT_Node *, NDT_Command, va_list); +typedef NDT_Status NDT_Manager( struct NDT_Root *, NDT_Index_Id, struct NDT_Node *, NDT_Command, va_list *); /* Pointeur de fonction sur l'allocateur */ @@ -562,8 +896,8 @@ NDD_DLL_API NDT_Status ND_DataStruct_Convert_C( NDT_Root *, NDT_Index_Type *) /* (I) Command: Commande à exécuter sur chaque noeud traversé */ /* (I) Data: pointeur de données utilisateur */ /*------------------------------------------------------------------------------*/ -NDD_DLL_API NDT_Status ND_DataStruct_Traverse_VI( NDT_Root *, NDT_Command, va_list); -NDD_DLL_API NDT_Status ND_DataStruct_Traverse_VC( NDT_Root *, NDT_Command, va_list); +NDD_DLL_API NDT_Status ND_DataStruct_Traverse_VI( NDT_Root *, NDT_Command, va_list *); +NDD_DLL_API NDT_Status ND_DataStruct_Traverse_VC( NDT_Root *, NDT_Command, va_list *); NDD_DLL_API NDT_Status ND_DataStruct_Traverse_I( NDT_Root *, NDT_Command, ...); NDD_DLL_API NDT_Status ND_DataStruct_Traverse_C( NDT_Root *, NDT_Command, ...); @@ -609,7 +943,7 @@ NDD_DLL_API NDT_Status ND_DataStruct_Value_Remove_C( NDT_Root *, void *); /* (I) Root: pointeur sur la racine de la structure de données */ /* (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_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, ...); @@ -624,8 +958,8 @@ NDD_DLL_API NDT_Status ND_DataStruct_Value_Print_C( FILE *, NDT_Root *, NDT_ /* (I) Data : pointeur de données */ /*------------------------------------------------------------------------------*/ -NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_VI( void **, NDT_Root *, void *, va_list); -NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_VC( void **, NDT_Root *, void *, va_list); +NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_VI( void **, NDT_Root *, void *, va_list *); +NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_VC( void **, NDT_Root *, void *, va_list *); NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_I( void **, NDT_Root *, void *, ...); NDD_DLL_API NDT_Status ND_DataStruct_Value_Find_C( void **, NDT_Root *, void *, ...); @@ -712,8 +1046,8 @@ NDD_DLL_API NDT_Status ND_Index_Reorg_C( NDT_Root *, NDT_Index_Id); /* (I) Command: Commande à exécuter sur chaque noeud traversé */ /* (I) Data: pointeur de données utilisateur */ /*------------------------------------------------------------------------------*/ -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_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, ...); @@ -761,7 +1095,7 @@ NDD_DLL_API NDT_Status ND_Index_Value_Remove_C( NDT_Root *, NDT_Index_Id, void /* (I) Root: pointeur sur la racine de la structure de données */ /* (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_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, ...); @@ -840,8 +1174,8 @@ NDD_DLL_API NDT_Status ND_Index_Node_Previous_Get_C( NDT_Node **, NDT_Node *) /* (I) Value : pointeur sur la valeur à rechercher */ /* (I) Data : pointeur de données */ /*------------------------------------------------------------------------------*/ -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_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 *, ...); @@ -886,8 +1220,8 @@ NDD_DLL_API NDT_Status ND_Value_Free_C( NDT_Root *, void *); /*------------------------------------------------------------------------------*/ /* (I) Function : nom de la fonction manager à exécuter */ /*------------------------------------------------------------------------------*/ -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_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, ...); diff --git a/src/libnode/src/libnode.c b/src/libnode/src/libnode.c index 3145883..fb55272 100644 --- a/src/libnode/src/libnode.c +++ b/src/libnode/src/libnode.c @@ -1,19 +1,10 @@ -/*----------------------------------------------------------------------------*/ -/* $Workfile: libnode.c $ */ -/*----------------------------------------------------------------------------*/ -/* $Author: agibert $ */ -/* $Date: 2008/11/12 02:25:23 $ */ -/* $Revision: 1.1 $ */ -/* $Label: $ */ -/*----------------------------------------------------------------------------*/ - /*---------------------------------------------------------------------------------*/ -/* %RCSfile: libnode.c,v % */ +/* $RCSfile: libnode.c,v $ */ /*---------------------------------------------------------------------------------*/ -/* %Revision: 2.15 % */ -/* %Name: libnode-2_1_0-1 % */ -/* %Date: 2005/01/19 23:59:41 % */ -/* %Author: agibert % */ +/* $Revision: 1.2 $ */ +/* $Name: $ */ +/* $Date: 2010/06/06 22:20:17 $ */ +/* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/ @@ -43,11 +34,9 @@ #include #ifdef _LIBVER_SUPPORT -VER_INFO_EXPORT( libnode, "%Revision: 2.15 %", "%Name: libnode-2_1_0-1 %", __FILE__, "%Author: agibert %") +VER_INFO_EXPORT( libnode, "$Revision: 1.2 $", "$Name: $", __FILE__, "$Author: agibert $") #endif -char IMRG_ND_WHAT_IDENT[] = "@(#) VERSIONIMR: $Label: $ $Date: 2008/11/12 02:25:23 $ $Workfile: libnode.c $"; - @@ -60,7 +49,7 @@ char IMRG_ND_WHAT_IDENT[] = "@(#) VERSIONIMR: $Label: $ $Date: 2008/11/12 02: /*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) +NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr) { NDT_Command_Name Command_Name; @@ -69,12 +58,12 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT { case NDD_CMD_MANAGER_VERSION: { - NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); + ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *); Command_Name = "NDD_CMD_MANAGER_VERSION"; - *Version_Name_Ptr = "%Revision: 2.15 % %Name: libnode-2_1_0-1 % %Date: 2005/01/19 23:59:41 % %Author: agibert %"; + *Version_Name_Ptr = "$Revision: 1.2 $ $Name: $ $Date: 2010/06/06 22:20:17 $ $Author: agibert $"; return( NDS_OK); } @@ -82,15 +71,15 @@ 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 *); + ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); + ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); + ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, 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 *); + ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); + ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); + ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); Command_Name = "NDD_CMD_INDEX_GET"; @@ -121,37 +110,45 @@ 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, ...); - */ + /* + ND_VA_ARG_GET( Value_Ptr_Ptr, *Args_Ptr, void **); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + */ Command_Name = "NDD_CMD_VALUE_ALLOC"; - /* - if( ( *Value_Ptr_Ptr = (void *)malloc( sizeof(void))) == NULL) - { - return(NDS_ERRMEM); - } - else - { - ... - - return( NDS_OK); - } - */ + /* + if( ( *Value_Ptr_Ptr = (void *)malloc( sizeof(void))) == NULL) + { + return(NDS_ERRMEM); + } + else + { + ... + + 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ @@ -167,89 +164,97 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT 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, ...); + ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, void *); + ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( 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); - } - } - + /* + 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ @@ -263,10 +268,14 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ @@ -278,18 +287,25 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT 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, ...); + /* + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - void *Value_Ptr = Node_Ptr->Value; + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); + + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_OPEN( user_args, lib_args); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + ND_VA_LIST_CLOSE( lib_args); + + void *Value_Ptr = Node_Ptr->Value; */ @@ -305,17 +321,22 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT 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, ...); + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - void *Value_Ptr = Node_Ptr->Value; + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); + + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_OPEN( user_args, lib_args); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + ND_VA_LIST_CLOSE( lib_args); */ @@ -328,13 +349,18 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT 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, ...); + /* + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - void *Value_Ptr = Node_Ptr->Value; + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + + + void *Value_Ptr = Node_Ptr->Value; */ @@ -366,7 +392,7 @@ NDT_Status ND_Default_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT /* 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_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr) { NDT_Command_Name Command_Name; @@ -375,12 +401,12 @@ NDT_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, { case NDD_CMD_MANAGER_VERSION: { - NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); + ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *); Command_Name = "NDD_CMD_MANAGER_VERSION"; - *Version_Name_Ptr = "%Revision: 2.15 % %Name: libnode-2_1_0-1 % %Date: 2005/01/19 23:59:41 % %Author: agibert %"; + *Version_Name_Ptr = "$Revision: 1.2 $ $Name: $ $Date: 2010/06/06 22:20:17 $ $Author: agibert $"; return( NDS_OK); } @@ -388,15 +414,15 @@ NDT_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, 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 *); + ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); + ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); + ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, 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 *); + ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); + ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); + ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); Command_Name = "NDD_CMD_INDEX_GET"; @@ -417,10 +443,14 @@ NDT_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, 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, ...); + ND_VA_ARG_GET( Value_Ptr_Ptr, *Args_Ptr, void **); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ @@ -432,10 +462,14 @@ NDT_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ @@ -447,15 +481,18 @@ NDT_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, 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, ...); - */ + ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, void *); + ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, void *); - void *Value1_Ptr = (void *)va_arg( Args, void *); - void *Value2_Ptr = (void *)va_arg( Args, void *); + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + */ + ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, void *); + ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, void *); Command_Name = "NDD_CMD_VALUE_COMP"; @@ -494,10 +531,14 @@ NDT_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ @@ -509,10 +550,14 @@ NDT_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ @@ -523,18 +568,25 @@ NDT_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, 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, ...); + /* + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - void *Value_Ptr = Node_Ptr->Value; + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); + + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_OPEN( user_args, lib_args); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + ND_VA_LIST_CLOSE( lib_args); + + void *Value_Ptr = Node_Ptr->Value; */ @@ -546,27 +598,35 @@ NDT_Status ND_OpenStruct_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, 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, ...); + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - void *Value_Ptr = Node_Ptr->Value; + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); + + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_OPEN( user_args, lib_args); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + ND_VA_LIST_CLOSE( lib_args); */ + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - 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); + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); - void *Value_Ptr = Node_Ptr->Value; + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_CLOSE( lib_args); + + void *Value_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_INFO_PRINT"; @@ -618,7 +678,7 @@ NDT_Status ND_Library_Open_I( int Debug_Mode) #if !defined(_WIN32) if( ( NDG_Base.DL_Ptr = dlopen( NULL, ( RTLD_NOW | RTLD_GLOBAL))) == NULL) { - sprintf( NDG_Base.Err_String, "Error ND_Library_Open: can't dlopen [%s]", dlerror()); + sprintf( NDG_Base.Err_String, "Error ND_Library_Open_I: can't dlopen [%s]", dlerror()); ND_Error_Print(); return( NDS_KO); @@ -693,16 +753,13 @@ NDT_Status ND_Library_Close_I( void) NDG_Base.Symbol_First_Ptr = (NDT_Symbol *)NULL; #if !defined(_WIN32) -/* if( dlclose( NDG_Base.DL_Ptr) != 0) { - sprintf( NDG_Base.Err_String, "Error ND_Library_Open: can't dlclose [%s]", dlerror()); + sprintf( NDG_Base.Err_String, "Error ND_Library_Close_I: can't dlclose [%s]", dlerror()); ND_Error_Print(); return( NDS_KO); } -*/ -/* dlclose buggy on HPUX... 8^/ */ #endif NDG_Base.Open_Status = NDD_FALSE; @@ -1050,7 +1107,7 @@ NDT_Status ND_DataStruct_Open_C( NDT_Root **Root_Ptr_Ptr, NDT_Index_Nb Index_ return( status); } - if( ( NDG_Base.Debug_Mode == NDD_TRUE) && ( NDG_Base.Open_Status == NDD_TRUE)) + if( ( NDG_Base.Debug_Mode == NDD_TRUE) && ( Manager_Ptr != NULL) && ( NDG_Base.Open_Status == NDD_TRUE)) { if( ( status = ND_DataStruct_Value_Add_I( NDG_Base.OpenStruct_Ptr, (void **)*Root_Ptr_Ptr)) != NDS_OK) { @@ -1876,7 +1933,7 @@ NDT_Status ND_DataStruct_Reorg_C( NDT_Root *Root_Ptr) /* (I) Data : pointeur de données utilisateur */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Index_Traverse_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Command Command, va_list Args) +NDT_Status ND_Index_Traverse_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Command Command, va_list *Args_Ptr) { NDT_Status rc; NDT_Node *Node_Ptr, *Next_Node_Ptr; @@ -1895,7 +1952,7 @@ NDT_Status ND_Index_Traverse_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND case NDD_CMD_VALUE_FREE: { - rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Node_Ptr->Value, Args); + rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Node_Ptr->Value, Args_Ptr); if (ND_ERROR( rc)) return rc; rc = ND_Index_Node_Remove_I( Node_Ptr); @@ -1909,7 +1966,7 @@ NDT_Status ND_Index_Traverse_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND default: { - rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Next_Node_Ptr, Args); + rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Next_Node_Ptr, Args_Ptr); if (ND_ERROR( rc)) return rc; break; @@ -1935,7 +1992,7 @@ NDT_Status ND_Index_Traverse_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND /* (I) Data : pointeur de données utilisateur */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Index_Traverse_VC( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Command Command, va_list Args) +NDT_Status ND_Index_Traverse_VC( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Command Command, va_list *Args_Ptr) { if( NDG_Base.Open_Status != NDD_TRUE) { @@ -1953,7 +2010,7 @@ NDT_Status ND_Index_Traverse_VC( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, N return( NDS_ERRAPI); } - return( ND_Index_Traverse_VI( Root_Ptr, Index_Id, Command, Args)); + return( ND_Index_Traverse_VI( Root_Ptr, Index_Id, Command, Args_Ptr)); } @@ -1993,7 +2050,7 @@ NDT_Status ND_Index_Traverse_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT case NDD_CMD_VALUE_FREE: { - status = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Node_Ptr->Value, args); + status = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Node_Ptr->Value, &args); if( ND_ERROR( status)) return( status); status = ND_Index_Node_Remove_I( Node_Ptr); @@ -2007,7 +2064,7 @@ NDT_Status ND_Index_Traverse_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT default: { - status = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Next_Node_Ptr, args); + status = ND_Manager_Exec_I( Root_Ptr, Index_Id, Node_Ptr, Command, Next_Node_Ptr, &args); if( ND_ERROR( status)) return( status); break; @@ -2059,7 +2116,7 @@ NDT_Status ND_Index_Traverse_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND return( NDS_ERRAPI); } - status = ND_Index_Traverse_VI( Root_Ptr, Index_Id, Command, args); + status = ND_Index_Traverse_VI( Root_Ptr, Index_Id, Command, &args); va_end( args); @@ -2079,7 +2136,7 @@ NDT_Status ND_Index_Traverse_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, ND /* (I) Data : pointeur de données utilisateur */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_DataStruct_Traverse_VI( NDT_Root *Root_Ptr, NDT_Command Command, va_list Args) +NDT_Status ND_DataStruct_Traverse_VI( NDT_Root *Root_Ptr, NDT_Command Command, va_list *Args_Ptr) { NDT_Status status; NDT_Index_Id new_index; @@ -2089,7 +2146,7 @@ NDT_Status ND_DataStruct_Traverse_VI( NDT_Root *Root_Ptr, NDT_Command Command, 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, new_index, new_cmd, Args)); + return( ND_Index_Traverse_VI( Root_Ptr, new_index, new_cmd, Args_Ptr)); } @@ -2105,7 +2162,7 @@ NDT_Status ND_DataStruct_Traverse_VI( NDT_Root *Root_Ptr, NDT_Command Command, /* (I) Data : pointeur de données utilisateur */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_DataStruct_Traverse_VC( NDT_Root *Root_Ptr, NDT_Command Command, va_list Args) +NDT_Status ND_DataStruct_Traverse_VC( NDT_Root *Root_Ptr, NDT_Command Command, va_list *Args_Ptr) { if( NDG_Base.Open_Status != NDD_TRUE) { @@ -2122,7 +2179,7 @@ NDT_Status ND_DataStruct_Traverse_VC( NDT_Root *Root_Ptr, NDT_Command Command return( NDS_ERRAPI); } - return( ND_DataStruct_Traverse_VI( Root_Ptr, Command, Args)); + return( ND_DataStruct_Traverse_VI( Root_Ptr, Command, Args_Ptr)); } @@ -2151,7 +2208,7 @@ NDT_Status ND_DataStruct_Traverse_I( NDT_Root *Root_Ptr, NDT_Command Command, 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, new_index, new_cmd, args); + status = ND_Index_Traverse_VI( Root_Ptr, new_index, new_cmd, &args); va_end( args); @@ -2195,7 +2252,7 @@ NDT_Status ND_DataStruct_Traverse_C( NDT_Root *Root_Ptr, NDT_Command Command, return( NDS_ERRAPI); } - status = ND_DataStruct_Traverse_VI( Root_Ptr, Command, args); + status = ND_DataStruct_Traverse_VI( Root_Ptr, Command, &args); va_end( args); @@ -2681,12 +2738,12 @@ NDT_Status ND_DataStruct_Value_Remove_C( NDT_Root *Root_Ptr, void *Value_Ptr) /* (I) Root : pointeur sur la racine de la structure de données à afficher */ /* (I) Out : flux de sortie */ /*------------------------------------------------------------------------------*/ -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 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_Ptr) { 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_Ptr); return( status); } @@ -2709,7 +2766,7 @@ NDT_Status ND_Index_Value_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_Id 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); @@ -2759,7 +2816,7 @@ NDT_Status ND_Index_Value_Print_C( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_I return( NDS_ERRAPI); } - status = ND_Index_Value_Print_VI( Out, Root_Ptr, Index_Id, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args); + status = ND_Index_Value_Print_VI( Out, Root_Ptr, Index_Id, Recursive_Mode, Recursive_Depth, Recursive_Offset, &user_args); va_end( user_args); @@ -2776,11 +2833,11 @@ NDT_Status ND_Index_Value_Print_C( FILE *Out, NDT_Root *Root_Ptr, NDT_Index_I /* (I) Root : pointeur sur la racine de la structure de données à afficher */ /* (I) Out : flux de sortie */ /*------------------------------------------------------------------------------*/ -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 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_Ptr) { 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_Ptr); return( status); } @@ -2803,7 +2860,7 @@ NDT_Status ND_DataStruct_Value_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Rec 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); @@ -2853,7 +2910,7 @@ NDT_Status ND_DataStruct_Value_Print_C( FILE *Out, NDT_Root *Root_Ptr, NDT_Re return( NDS_ERRAPI); } - status = ND_DataStruct_Value_Print_VI( Out, Root_Ptr, Recursive_Mode, Recursive_Depth, Recursive_Offset, user_args); + status = ND_DataStruct_Value_Print_VI( Out, Root_Ptr, Recursive_Mode, Recursive_Depth, Recursive_Offset, &user_args); va_end( user_args); @@ -3315,15 +3372,15 @@ NDT_Status ND_Index_Node_Previous_Get_C( NDT_Node **Prev_Node_Ptr_Ptr, NDT_Nod /* (I) Data : pointeur de données */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Index_Node_Find_VI( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void *Value_Ptr, va_list Args) +NDT_Status ND_Index_Node_Find_VI( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void *Value_Ptr, va_list *Args_Ptr) { if( ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id)) { - *Node_Ptr_Ptr = ND_List_Node_Find( Root_Ptr, Index_Id, Value_Ptr, Args); + *Node_Ptr_Ptr = ND_List_Node_Find( Root_Ptr, Index_Id, Value_Ptr, Args_Ptr); } else if ( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id)) { - *Node_Ptr_Ptr = ND_Tree_Node_Find( Root_Ptr, Index_Id, Value_Ptr, Args); + *Node_Ptr_Ptr = ND_Tree_Node_Find( Root_Ptr, Index_Id, Value_Ptr, Args_Ptr); } else { @@ -3349,7 +3406,7 @@ NDT_Status ND_Index_Node_Find_VI( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr /* (I) Data : pointeur de données */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Index_Node_Find_VC( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void *Value_Ptr, va_list Args) +NDT_Status ND_Index_Node_Find_VC( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void *Value_Ptr, va_list *Args_Ptr) { NDT_Status status; @@ -3378,7 +3435,7 @@ NDT_Status ND_Index_Node_Find_VC( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr return( NDS_ERRAPI); } - status = ND_Index_Node_Find_VI( Node_Ptr_Ptr, Root_Ptr, Index_Id, Value_Ptr, Args); + status = ND_Index_Node_Find_VI( Node_Ptr_Ptr, Root_Ptr, Index_Id, Value_Ptr, Args_Ptr); return( status); @@ -3406,11 +3463,11 @@ NDT_Status ND_Index_Node_Find_I( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr, if( ND_INDEX_TYPE_LIST_IS( Root_Ptr, Index_Id)) { - *Node_Ptr_Ptr = ND_List_Node_Find( Root_Ptr, Index_Id, Value_Ptr, user_args); + *Node_Ptr_Ptr = ND_List_Node_Find( Root_Ptr, Index_Id, Value_Ptr, &user_args); } else if ( ND_INDEX_TYPE_TREE_IS( Root_Ptr, Index_Id)) { - *Node_Ptr_Ptr = ND_Tree_Node_Find( Root_Ptr, Index_Id, Value_Ptr, user_args); + *Node_Ptr_Ptr = ND_Tree_Node_Find( Root_Ptr, Index_Id, Value_Ptr, &user_args); } else { @@ -3468,7 +3525,7 @@ NDT_Status ND_Index_Node_Find_C( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr, return( NDS_ERRAPI); } - status = ND_Index_Node_Find_VI( Node_Ptr_Ptr, Root_Ptr, Index_Id, Value_Ptr, user_args); + status = ND_Index_Node_Find_VI( Node_Ptr_Ptr, Root_Ptr, Index_Id, Value_Ptr, &user_args); va_end( user_args); @@ -3488,7 +3545,7 @@ NDT_Status ND_Index_Node_Find_C( NDT_Node **Node_Ptr_Ptr, NDT_Root *Root_Ptr, /* (I) Data : pointeur de données */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_DataStruct_Value_Find_VI( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, va_list Args) +NDT_Status ND_DataStruct_Value_Find_VI( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, va_list *Args_Ptr) { NDT_Status status; NDT_Index_Id new_index; @@ -3499,7 +3556,7 @@ NDT_Status ND_DataStruct_Value_Find_VI( void **Value_Ptr_Ptr, NDT_Root *Root_ 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); + status = ND_Index_Node_Find_VI( &node_ptr, Root_Ptr, new_index, Ref_Value_Ptr, Args_Ptr); if( ND_ERROR(status)) return( status); if( node_ptr != NULL) @@ -3527,7 +3584,7 @@ NDT_Status ND_DataStruct_Value_Find_VI( void **Value_Ptr_Ptr, NDT_Root *Root_ /* (I) Data : pointeur de données */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_DataStruct_Value_Find_VC( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, va_list Args) +NDT_Status ND_DataStruct_Value_Find_VC( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, void *Ref_Value_Ptr, va_list *Args_Ptr) { NDT_Status status; @@ -3556,7 +3613,7 @@ NDT_Status ND_DataStruct_Value_Find_VC( void **Value_Ptr_Ptr, NDT_Root *Root_ return( NDS_ERRAPI); } - status = ND_DataStruct_Value_Find_VI( Value_Ptr_Ptr, Root_Ptr, Ref_Value_Ptr, Args); + status = ND_DataStruct_Value_Find_VI( Value_Ptr_Ptr, Root_Ptr, Ref_Value_Ptr, Args_Ptr); return( status); } @@ -3588,7 +3645,7 @@ NDT_Status ND_DataStruct_Value_Find_I( void **Value_Ptr_Ptr, NDT_Root *Root_P 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, user_args); + status = ND_Index_Node_Find_VI( &node_ptr, Root_Ptr, new_index, Ref_Value_Ptr, &user_args); if( ND_ERROR(status)) return( status); if( node_ptr != NULL) @@ -3650,7 +3707,7 @@ NDT_Status ND_DataStruct_Value_Find_C( void **Value_Ptr_Ptr, NDT_Root *Root_P return( NDS_ERRAPI); } - status = ND_DataStruct_Value_Find_VI( Value_Ptr_Ptr, Root_Ptr, Ref_Value_Ptr, user_args); + status = ND_DataStruct_Value_Find_VI( Value_Ptr_Ptr, Root_Ptr, Ref_Value_Ptr, &user_args); va_end( user_args); @@ -3722,7 +3779,7 @@ NDT_Status ND_Node_Root_Get_C( NDT_Root **Root_Ptr_Ptr, NDT_Node *Node_Ptr ) NDT_Status ND_Value_Alloc_I( NDT_Root *Root_Ptr, void **Value_Ptr_Ptr, ...) { NDT_Status rc; - va_list user_args; + va_list user_args; /* Récupération des arguments pour l'allocation de la valeur */ @@ -3731,7 +3788,7 @@ 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); @@ -3778,7 +3835,7 @@ NDT_Status ND_Value_Alloc_C( 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); @@ -3852,7 +3909,7 @@ NDT_Status ND_Value_Free_C( NDT_Root *Root_Ptr, void *Value_Ptr) /* (I) Function : nom de la fonction manager à exécuter */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Manager_Exec_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) +NDT_Status ND_Manager_Exec_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr) { NDT_Status status; NDT_Manager *manager_ptr; @@ -3873,7 +3930,7 @@ NDT_Status ND_Manager_Exec_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT } } - status = manager_ptr( Root_Ptr, Index_Id, Node_Ptr, Command, Args); + status = manager_ptr( Root_Ptr, Index_Id, Node_Ptr, Command, Args_Ptr); return( status); } @@ -3887,7 +3944,7 @@ NDT_Status ND_Manager_Exec_VI( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT /* (I) Function : nom de la fonction manager à exécuter */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Manager_Exec_VC( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) +NDT_Status ND_Manager_Exec_VC( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr) { NDT_Status status; @@ -3916,7 +3973,7 @@ NDT_Status ND_Manager_Exec_VC( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT return( NDS_ERRAPI); } - status = ND_Manager_Exec_VI( Root_Ptr, Index_Id, Node_Ptr, Command, Args); + status = ND_Manager_Exec_VI( Root_Ptr, Index_Id, Node_Ptr, Command, Args_Ptr); return( status); } @@ -3955,7 +4012,7 @@ NDT_Status ND_Manager_Exec_I( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_ } } - status = manager_ptr( Root_Ptr, Index_Id, Node_Ptr, Command, args); + status = manager_ptr( Root_Ptr, Index_Id, Node_Ptr, Command, &args); va_end( args); @@ -4004,7 +4061,7 @@ NDT_Status ND_Manager_Exec_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_ return( NDS_ERRAPI); } - status = ND_Manager_Exec_VI( Root_Ptr, Index_Id, Node_Ptr, Command, args); + status = ND_Manager_Exec_VI( Root_Ptr, Index_Id, Node_Ptr, Command, &args); va_end( args); @@ -4618,7 +4675,7 @@ NDT_Status ND_Tree_Value_Add( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void /* (I) Data : pointeur de données */ /*------------------------------------------------------------------------------*/ -NDT_Node *ND_List_Node_Find( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void *Value_Ptr, va_list User_Args) +NDT_Node *ND_List_Node_Find( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void *Value_Ptr, va_list *User_Args_Ptr) { NDT_Node *node_ptr; NDT_Status rc; @@ -4632,7 +4689,7 @@ NDT_Node *ND_List_Node_Find( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void while( node_ptr) { - rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, Value_Ptr, node_ptr->Value, User_Args); + rc = ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, Value_Ptr, node_ptr->Value, User_Args_Ptr); switch( rc) { @@ -4660,7 +4717,7 @@ 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)) + while( node_ptr && ( ND_Manager_Exec_I( Root_Ptr, Index_Id, node_ptr, NDD_CMD_VALUE_COMP, Value_Ptr, node_ptr->Value, User_Args_Ptr) != NDS_EQUAL)) { node_ptr = node_ptr->Right; } @@ -4683,14 +4740,14 @@ NDT_Node *ND_List_Node_Find( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void /*------------------------------ Recursive Kernel ------------------------------*/ -NDT_Node *ND_Tree_Node_Recursive_Find( NDT_Node *Node_Ptr, void *Value_Ptr, va_list User_Args) +NDT_Node *ND_Tree_Node_Recursive_Find( NDT_Node *Node_Ptr, void *Value_Ptr, va_list *User_Args_Ptr) { NDT_Status answer; if( !Node_Ptr) return(NULL); - answer = ND_Manager_Exec_I( Node_Ptr->Root, Node_Ptr->Index, Node_Ptr, NDD_CMD_VALUE_COMP, Value_Ptr, Node_Ptr->Value, User_Args); + answer = ND_Manager_Exec_I( Node_Ptr->Root, Node_Ptr->Index, Node_Ptr, NDD_CMD_VALUE_COMP, Value_Ptr, Node_Ptr->Value, User_Args_Ptr); /* Noeud trouvé */ @@ -4698,9 +4755,9 @@ NDT_Node *ND_Tree_Node_Recursive_Find( NDT_Node *Node_Ptr, void *Value_Ptr, v /* Continuation de la recherche par appel récursif */ - if( answer == NDS_LOWER) return( ND_Tree_Node_Recursive_Find( Node_Ptr->Left, Value_Ptr, User_Args)); + if( answer == NDS_LOWER) return( ND_Tree_Node_Recursive_Find( Node_Ptr->Left, Value_Ptr, User_Args_Ptr)); - if( answer == NDS_GREATER) return( ND_Tree_Node_Recursive_Find( Node_Ptr->Right, Value_Ptr, User_Args)); + if( answer == NDS_GREATER) return( ND_Tree_Node_Recursive_Find( Node_Ptr->Right, Value_Ptr, User_Args_Ptr)); return( NULL); } @@ -4709,9 +4766,9 @@ NDT_Node *ND_Tree_Node_Recursive_Find( NDT_Node *Node_Ptr, void *Value_Ptr, v /*-------------------------------- main body ---------------------------------*/ -NDT_Node *ND_Tree_Node_Find( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void *Value_Ptr, va_list User_Args) +NDT_Node *ND_Tree_Node_Find( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, void *Value_Ptr, va_list *User_Args_Ptr) { - return( ND_Tree_Node_Recursive_Find( Root_Ptr->Index_Tab[Index_Id].Head, Value_Ptr, User_Args)); + return( ND_Tree_Node_Recursive_Find( Root_Ptr->Index_Tab[Index_Id].Head, Value_Ptr, User_Args_Ptr)); } diff --git a/src/libnode/src/libnode.h b/src/libnode/src/libnode.h index 6793135..d86af4f 100644 --- a/src/libnode/src/libnode.h +++ b/src/libnode/src/libnode.h @@ -1,19 +1,10 @@ -/*----------------------------------------------------------------------------*/ -/* $Workfile: libnode.h $ */ -/*----------------------------------------------------------------------------*/ -/* $Author: agibert $ */ -/* $Date: 2008/11/12 02:25:23 $ */ -/* $Revision: 1.1 $ */ -/* $Label: $ */ -/*----------------------------------------------------------------------------*/ - /*---------------------------------------------------------------------------------*/ -/* %RCSfile: libnode.h,v % */ +/* $RCSfile: libnode.h,v $ */ /*---------------------------------------------------------------------------------*/ -/* %Revision: 2.9 % */ -/* %Name: libnode-2_1_0-1 % */ -/* %Date: 2005/01/19 23:59:42 % */ -/* %Author: agibert % */ +/* $Revision: 1.2 $ */ +/* $Name: $ */ +/* $Date: 2010/06/06 22:20:17 $ */ +/* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/ @@ -136,14 +127,14 @@ NDT_Base NDG_Base = /*------------------------------------------------------------------------------*/ /* (I) va_list Arguments : Liste d'arguments contextuels */ /*------------------------------------------------------------------------------*/ -NDT_Status ND_Default_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, 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); +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 */ @@ -242,12 +233,12 @@ 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 */ @@ -337,7 +328,7 @@ NDT_Node *ND_Tree_Node_First_Recursive_Get( NDT_Node *); NDT_Node *ND_Tree_Node_Last_Recursive_Get( NDT_Node *); -NDT_Node *ND_Tree_Node_Recursive_Find( NDT_Node *, void *, va_list); +NDT_Node *ND_Tree_Node_Recursive_Find( NDT_Node *, void *, va_list *); NDT_Node *ND_Tree_Parent_Next_Recursive_Get( NDT_Node *); diff --git a/src/libnode/util/ndbench.c b/src/libnode/util/ndbench.c index 6e232a0..7990d57 100644 --- a/src/libnode/util/ndbench.c +++ b/src/libnode/util/ndbench.c @@ -1,10 +1,10 @@ /*---------------------------------------------------------------------------------*/ -/* %RCSfile: ndbench.c,v % */ +/* $RCSfile: ndbench.c,v $ */ /*---------------------------------------------------------------------------------*/ -/* %Revision: 2.9 % */ -/* %Name: libnode-2_1_0-1 % */ -/* %Date: 2005/01/20 00:07:27 % */ -/* %Author: agibert % */ +/* $Revision: 1.2 $ */ +/* $Name: $ */ +/* $Date: 2010/06/06 22:20:17 $ */ +/* $Author: agibert $ */ /*---------------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------------*/ @@ -59,7 +59,7 @@ /*---------------------------------------------------------------------------------*/ #ifdef _LIBVER_SUPPORT -VER_INFO_EXPORT( ndbench, "%Revision: 2.9 %", "%Name: libnode-2_1_0-1 %", __FILE__, "%Author: agibert %"); +VER_INFO_EXPORT( ndbench, "$Revision: 1.2 $", "$Name: $", __FILE__, "$Author: agibert $"); # define USAGE "Usage : %s [ --help | --version [-v] | --batch_run ]\n" #else # define USAGE "Usage : %s [ --help | --batch_run ]\n" @@ -200,7 +200,7 @@ NDT_Index_Type idx_type_balanced_tree = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYP /* Prototype */ /*---------------------------------------------------------------------------------*/ -NDT_Status Module_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list); +NDT_Status Module_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *); void Menu_Print( FILE *, NDT_Root *); void Command_Get( int *, char **, char **, FILE *, FILE *, short); @@ -258,7 +258,7 @@ Command Command_Tab[] = /* */ /*---------------------------------------------------------------------------------*/ -NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) +NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr) { NDT_Command_Name Command_Name; @@ -267,11 +267,12 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod { case NDD_CMD_MANAGER_VERSION: { - NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); + ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *); + Command_Name = "NDD_CMD_MANAGER_VERSION"; - *Version_Name_Ptr = "%Revision: 2.9 % %Name: libnode-2_1_0-1 % %Date: 2005/01/20 00:07:27 % %Author: agibert %"; + *Version_Name_Ptr = "$Revision: 1.2 $ $Name: $ $Date: 2010/06/06 22:20:17 $ $Author: agibert $"; return( NDS_OK); } @@ -279,15 +280,15 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod 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 *); + ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); + ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); + ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, 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); - T_Module **Module_Ptr_Ptr = (T_Module **)va_arg( Args, T_Module **); + ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); + ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); + ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); + ND_VA_ARG_GET( Module_Ptr_Ptr, *Args_Ptr, T_Module **); Command_Name = "NDD_CMD_INDEX_GET"; @@ -318,15 +319,23 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod 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, ...); + ND_VA_ARG_GET( Value_Ptr_Ptr, *Args_Ptr, void **); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ - T_Module **Module_Ptr_Ptr = (T_Module **)va_arg( Args, T_Module **); - va_list user_args = (va_list)va_arg( Args, va_list); - char *Nom = (char *)va_arg( user_args, char *); - int Id = (int)va_arg( user_args, int); + ND_VA_ARG_GET( Module_Ptr_Ptr, *Args_Ptr, T_Module **); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( Nom, user_args, char *); + ND_VA_ARG_GET( Id, user_args, int); + + ND_VA_LIST_CLOSE( user_args); Command_Name = "NDD_CMD_VALUE_ALLOC"; @@ -348,12 +357,16 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ - T_Module *Module_Ptr = (T_Module *)va_arg( Args, T_Module *); + ND_VA_ARG_GET( Module_Ptr, *Args_Ptr, T_Module *); Command_Name = "NDD_CMD_VALUE_FREE"; @@ -368,14 +381,18 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod 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, ...); + ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, void *); + ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ - T_Module *Value1 = (T_Module *)va_arg( Args, T_Module *); - T_Module *Value2 = (T_Module *)va_arg( Args, T_Module *); + ND_VA_ARG_GET( Module1_Ptr, *Args_Ptr, T_Module *); + ND_VA_ARG_GET( Module2_Ptr, *Args_Ptr, T_Module *); Command_Name = "NDD_CMD_VALUE_COMP"; @@ -385,7 +402,7 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod int rc; - rc = Value1->Id - Value2->Id; + rc = Module1_Ptr->Id - Module2_Ptr->Id; if( rc < 0) { @@ -415,10 +432,14 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ @@ -430,10 +451,14 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod 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, ...); + ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); + + ND_VA_LIST_OPEN( user_args, *Args_Ptr); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); */ @@ -443,25 +468,38 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod 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); - 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, ...); + /* + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - void *Value_Ptr = Node_Ptr->Value; + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); + + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_OPEN( user_args, lib_args); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + ND_VA_LIST_CLOSE( lib_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); + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - T_Module *Module_Ptr = Node_Ptr->Value; + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); + + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_CLOSE( lib_args); + + T_Module *Module_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_VALUE_PRINT"; @@ -474,16 +512,22 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod 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); - 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, ...); + ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); - void *Value_Ptr = Node_Ptr->Value; + ND_VA_LIST_OPEN( lib_args, *Args_Ptr); + + ND_VA_ARG_GET( Out, lib_args, FILE *); + ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); + ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); + ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); + + ND_VA_LIST_OPEN( user_args, lib_args); + + ND_VA_ARG_GET( user_data, user_args, user_type); + ND_VA_ARG_GET( ..., user_args, ...); + + ND_VA_LIST_CLOSE( user_args); + ND_VA_LIST_CLOSE( lib_args); */ diff --git a/src/libnode/util/ndbench.xls b/src/libnode/util/ndbench.xls new file mode 100644 index 0000000000000000000000000000000000000000..b80ce7caf6dc3d9d5cab0c9620d0e5f394a2651b GIT binary patch literal 16896 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 literal 0 HcmV?d00001