libnode/include/node.h

/*---------------------------------------------------------------------------------*/
/* $RCSfile: node.h,v $														   */
/*---------------------------------------------------------------------------------*/
/* $Revision: 2.2 $															   */
/* $Name:  $															   */
/* $Date: 2002/02/25 23:34:36 $													   */
/* $Author: agibert $															   */
/*---------------------------------------------------------------------------------*/



#ifndef _LIBNODE
#define _LIBNODE

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <stdarg.h>

#ifdef _LIBVER_SUPPORT
#   include <ver.h>
#endif







#define NDD_TRUE  1

#define NDD_FALSE 0

#define NDD_MIN(A,B)  ((A > B) ? B : A)

#define NDD_MAX(A,B)  ((A < B) ? B : A)



/*
    Diff<EFBFBD>rence de profondeur entre la branche la plus courte et
    la plus longue d'un arbre.
    Le d<EFBFBD>passement de ce seuil provoque le r<EFBFBD><EFBFBD>quilibrage de l'arbre
*/

#define DEF_MAX_DIF   100

/* Types de structure */

typedef short  NDT_Root_Type;

typedef int NDT_Index_Type;

#define NDD_INDEX_MSK               0xffff
#define NDD_INDEX_RMSK              0x0000

#define NDD_INDEX_STATUS_UNKNOWN    0x0000
#define NDD_INDEX_STATUS_OPENED     0x0001
#define NDD_INDEX_STATUS_CLOSED     0x0002
#define NDD_INDEX_STATUS_MSK        (NDD_INDEX_STATUS_UNKNOWN | NDD_INDEX_STATUS_OPENED | NDD_INDEX_STATUS_CLOSED)
#define NDD_INDEX_STATUS_RMSK       (NDD_INDEX_MSK ^ NDD_INDEX_STATUS_MSK)

#define ND_INDEX_STATUS_VALUE_UNKNOWN_IS( v)    ( ( (v) & NDD_INDEX_STATUS_MSK) == NDD_INDEX_STATUS_UNKNOWN)
#define ND_INDEX_STATUS_VALUE_OPENED_IS( v)     ( ( (v) & NDD_INDEX_STATUS_MSK) == NDD_INDEX_STATUS_OPENED)
#define ND_INDEX_STATUS_VALUE_CLOSED_IS( v)     ( ( (v) & NDD_INDEX_STATUS_MSK) == NDD_INDEX_STATUS_CLOSED)
#define ND_INDEX_STATUS_UNKNOWN_IS( r, i)       ND_INDEX_STATUS_VALUE_UNKNOWN_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_STATUS_OPENED_IS( r, i)        ND_INDEX_STATUS_VALUE_OPENED_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_STATUS_CLOSED_IS( r, i)        ND_INDEX_STATUS_VALUE_CLOSED_IS( (r)->Index_Tab[(i)].Type)

#define ND_INDEX_STATUS_VALUE_ASCII_GET( v)     ( ND_INDEX_STATUS_VALUE_UNKNOWN_IS( (v)) ? "UNKNOWN" : ( ND_INDEX_STATUS_VALUE_OPENED_IS( (v)) ? "OPENED" : ( ND_INDEX_STATUS_VALUE_CLOSED_IS( (v)) ? "CLOSED" : "???")))
#define ND_INDEX_STATUS_ASCII_GET( r, i)        ND_INDEX_STATUS_VALUE_ASCII_GET( (r)->Index_Tab[(i)].Type)



#define NDD_INDEX_TYPE_UNKNOWN      0x0000
#define NDD_INDEX_TYPE_LIST         0x0010
#define NDD_INDEX_TYPE_TREE         0x0020
#define NDD_INDEX_TYPE_MSK          (NDD_INDEX_TYPE_UNKNOWN | NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)
#define NDD_INDEX_TYPE_RMSK         (NDD_INDEX_MSK ^ NDD_INDEX_TYPE_MSK)

#define ND_INDEX_TYPE_VALUE_UNKNOWN_IS( v)  ( ( (v) & NDD_INDEX_TYPE_MSK) == NDD_INDEX_TYPE_UNKNOWN)
#define ND_INDEX_TYPE_VALUE_LIST_IS( v)     ( ( (v) & NDD_INDEX_TYPE_MSK) == NDD_INDEX_TYPE_LIST)
#define ND_INDEX_TYPE_VALUE_TREE_IS( v)     ( ( (v) & NDD_INDEX_TYPE_MSK) == NDD_INDEX_TYPE_TREE)

#define ND_INDEX_TYPE_UNKNOWN_IS( r, i)     ND_INDEX_TYPE_VALUE_UNKNOWN_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_TYPE_LIST_IS( r, i)        ND_INDEX_TYPE_VALUE_LIST_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_TYPE_TREE_IS( r, i)        ND_INDEX_TYPE_VALUE_TREE_IS( (r)->Index_Tab[(i)].Type)

#define ND_INDEX_TYPE_VALUE_ASCII_GET( v)   ( ND_INDEX_TYPE_VALUE_UNKNOWN_IS( (v)) ? "UNKNOWN" : ( ND_INDEX_TYPE_VALUE_LIST_IS( (v)) ? "LIST" : ( ND_INDEX_TYPE_VALUE_TREE_IS( (v)) ? "TREE" : "???")))

#define ND_INDEX_TYPE_ASCII_GET( r, i)      ND_INDEX_TYPE_VALUE_ASCII_GET( (r)->Index_Tab[(i)].Type)



#define NDD_INDEX_SUBTYPE_UNKNOWN      0x0000
#define NDD_INDEX_SUBTYPE_FIFO         0x0100    /* principe de la file d'attente (First In First Out) */
#define NDD_INDEX_SUBTYPE_LILO         NDD_INDEX_SUBTYPE_FIFO
#define NDD_INDEX_SUBTYPE_LIFO         0x0200    /* principe de la pile (First In Last Out) */
#define NDD_INDEX_SUBTYPE_FILO         NDD_INDEX_SUBTYPE_LIFO
#define NDD_INDEX_SUBTYPE_SORTED       0x0300    /* liste tri<72>e */
#define NDD_INDEX_SUBTYPE_UNBALANCED   0x0400
#define NDD_INDEX_SUBTYPE_BALANCED     0x0500    /* arbre auto-<2D>quilibr<62> */
#define NDD_INDEX_SUBTYPE_MSK          ( NDD_INDEX_SUBTYPE_UNKNOWN | NDD_INDEX_SUBTYPE_FIFO | NDD_INDEX_SUBTYPE_FILO | NDD_INDEX_SUBTYPE_SORTED | NDD_INDEX_SUBTYPE_UNBALANCED | NDD_INDEX_SUBTYPE_BALANCED)
#define NDD_INDEX_SUBTYPE_RMSK         (NDD_INDEX_MSK ^ NDD_INDEX_SUBTYPE_MSK)

#define ND_INDEX_SUBTYPE_VALUE_UNKNOWN_IS( v)     ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_UNKNOWN)
#define ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v)        ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_FIFO)
#define ND_INDEX_SUBTYPE_VALUE_LILO_IS( v)	      ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v)
#define ND_INDEX_SUBTYPE_VALUE_LIFO_IS( v)	      ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_LIFO)
#define ND_INDEX_SUBTYPE_VALUE_FILO_IS( v)	      ND_INDEX_SUBTYPE_LIFO_IS( r, i)
#define ND_INDEX_SUBTYPE_VALUE_SORTED_IS( v)      ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_SORTED)
#define ND_INDEX_SUBTYPE_VALUE_UNBALANCED_IS( v)  ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_UNBALANCED)
#define ND_INDEX_SUBTYPE_VALUE_BALANCED_IS( v)    ( ( (v) & NDD_INDEX_SUBTYPE_MSK) == NDD_INDEX_SUBTYPE_BALANCED)

#define ND_INDEX_SUBTYPE_UNKNOWN_IS( r, i)        ND_INDEX_SUBTYPE_VALUE_UNKNOWN_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_SUBTYPE_FIFO_IS( r, i)           ND_INDEX_SUBTYPE_VALUE_FIFO_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_SUBTYPE_LILO_IS( r, i)	          ND_INDEX_SUBTYPE_VALUE_LILO_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_SUBTYPE_LIFO_IS( r, i)	          ND_INDEX_SUBTYPE_VALUE_LIFO_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_SUBTYPE_FILO_IS( r, i)	          ND_INDEX_SUBTYPE_VALUE_FILO_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_SUBTYPE_SORTED_IS( r, i)         ND_INDEX_SUBTYPE_VALUE_SORTED_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_SUBTYPE_UNBALANCED_IS( r, i)     ND_INDEX_SUBTYPE_VALUE_UNBALANCED_IS( (r)->Index_Tab[(i)].Type)
#define ND_INDEX_SUBTYPE_BALANCED_IS( r, i)       ND_INDEX_SUBTYPE_VALUE_BALANCED_IS( (r)->Index_Tab[(i)].Type)

#define ND_INDEX_SUBTYPE_VALUE_ASCII_GET( v)      ( ND_INDEX_SUBTYPE_VALUE_UNKNOWN_IS( v) ? "UNKNOWN" : ( ND_INDEX_SUBTYPE_VALUE_FIFO_IS( v) ? "FIFO" : ( ND_INDEX_SUBTYPE_VALUE_LIFO_IS( v) ? "LIFO" : ( ND_INDEX_SUBTYPE_VALUE_SORTED_IS( v) ? "SORTED" : ( ND_INDEX_SUBTYPE_VALUE_UNBALANCED_IS( v) ? "UNBALANCED" : ( ND_INDEX_SUBTYPE_VALUE_BALANCED_IS( v) ? "BALANCED" : "???"))))))
#define ND_INDEX_SUBTYPE_ASCII_GET( r, i)         ND_INDEX_SUBTYPE_VALUE_ASCII_GET( (r)->Index_Tab[(i)].Type)



/* Commandes du manager */

typedef int  NDT_Command;

#define NDD_CMD_UNKNOWN	        (NDT_Command)0
#define NDD_CMD_MANAGER_VERSION	(NDT_Command)1
#define NDD_CMD_INDEX_GET       (NDT_Command)2
#define NDD_CMD_VALUE_ALLOC     (NDT_Command)3
#define NDD_CMD_VALUE_FREE      (NDT_Command)4
#define NDD_CMD_VALUE_COMP      (NDT_Command)5
#define NDD_CMD_VALUE_ADD       (NDT_Command)6
#define NDD_CMD_VALUE_REMOVE    (NDT_Command)7
#define NDD_CMD_VALUE_PRINT     (NDT_Command)8
#define NDD_CMD_VALUE_FIND      (NDT_Command)9
#define NDD_CMD_INFO_PRINT      (NDT_Command)10

#define NDD_CMD_USER_TRAVERSE	(NDT_Command)17


typedef char  *NDT_Command_Name;
typedef char  *NDT_Version_Name;



/* Types de r<>ponse du manager ou code retour des diverses fonctions */

typedef int NDT_Status;

#define ND_ERROR(s)               ((s) <= 0)	/* All negative or 0 status are errors */

#define NDS_OK                     1
#define NDS_KO                     0

#define NDS_YES                    1
#define NDS_NO                     0

#define NDS_EQUAL                  1
#define NDS_GREATER                2
#define NDS_LOWER                  3

#define NDS_ERRMEM                -1       /* Probl<62>me d'allocation m<>moire */
#define NDS_ERRAPI                -2       /* Utilisation incorrecte des API */



typedef short  NDT_Index_Id;
typedef short  NDT_Index_Nb;

#define NDD_INDEX_UNKNOWN  (NDT_Index_Id)-1
#define NDD_INDEX_PRIMARY  (NDT_Index_Id)0



struct NDT_Root;
struct NDT_Node;



/* Pointeur de fonction sur le manager */

#define NDD_MANAGER_NAME_LEN_MAX   64
#define NDD_MANAGER_NAME_SIZE_MAX  (NDD_MANAGER_NAME_LEN_MAX + 1)

typedef char  *NDT_Manager_Name;

typedef NDT_Status NDT_Manager( struct NDT_Root  *, NDT_Index_Id, struct NDT_Node  *, NDT_Command, va_list);


/* Pointeur de fonction sur l'allocateur */

#define NDD_ALLOCATOR_NAME_LEN_MAX   64
#define NDD_ALLOCATOR_NAME_SIZE_MAX  (NDD_ALLOCATOR_NAME_LEN_MAX + 1)

typedef char  *NDT_Allocator_Name;

typedef NDT_Status NDT_Allocator(size_t, void **, void *);


/* Pointeur de fonction sur le d<>sallocateur */

#define NDD_DESALLOCATOR_NAME_LEN_MAX   64
#define NDD_DESALLOCATOR_NAME_SIZE_MAX  (NDD_DESALLOCATOR_NAME_LEN_MAX + 1)

typedef char  *NDT_Desallocator_Name;

typedef NDT_Status NDT_Desallocator(void *, void *);




typedef struct NDT_Index
{
	NDT_Index_Type   Type;               /* Type de la structure (liste, arbre ... ) */

	long                  Node_Number;        /* Nombre de noeuds dans la structure */
	long                  Min_Depth;          /* Profondeur minimale de l'arbre */
	long                  Max_Depth;          /* Profondeur maximale de l'arbre */
	long                  Max_Dif;            /* Diff<66>rence maximale autoris<69>e entre la branche la plus courte et la plus longue */
	long                  Nb_Equ;             /* Nombre de r<>quilibrages r<>alis<69>s sur l'arbre */
	struct NDT_Node *     Head;               /* Noeud de t<>te */
	struct NDT_Node *     Tail;              /* Noeud de queue */
	struct NDT_Node *     Save;               /* Pointeur de sauvegarde (utile pour la fonction de restauration) */

} NDT_Index;



typedef struct NDT_Root
{
//	NDT_Root_Type		  Type;				/* Root Structure Type */
//	NDT_DataStruct_Type   DS_Type;			/* Type de la structure (liste, arbre ... ) */

    NDT_Manager       *Manager_Ptr;									 /* Pointeur sur la fonction manager */
    char               Manager_Name[NDD_MANAGER_NAME_SIZE_MAX];		 /* Nom de la fonction manager */
    NDT_Allocator     *Allocator_Ptr;								 /* Pointeur sur la fonction d'allocation */
    char               Allocator_Name[NDD_ALLOCATOR_NAME_SIZE_MAX];    /* Nom de la fonction d'allocation */
    NDT_Desallocator  *Desallocator_Ptr;							 /* Pointeur sur la fonction de d<>sallocation */
    char               Desallocator_Name[NDD_DESALLOCATOR_NAME_SIZE_MAX]; /* Nom de la fonction de d<>sallocation */

    short              Own_Value;              /* Indique si la structure est propri<72>taire de ses valeurs */
    void              *User;                   /* Pointeur utilisable librement par l'utilisateur */

    NDT_Index_Nb       Index_Nb;
    NDT_Index_Nb       Index_Open_Count;
    NDT_Index          Index_Tab[0];

} NDT_Root;



typedef struct NDT_DataStruct
{

	NDT_Root		  *Root_Ptr;

    NDT_Manager       *Manager_Ptr;            /* Manager function pointer */
    NDT_Allocator     *Allocator_Ptr;          /* Allocator function pointer */
    NDT_Desallocator  *Desallocator_Ptr;       /* Desallocator function pointer */

} NDT_DataStruct;



/* Structure de noeud */

typedef struct NDT_Node
{
	NDT_Root		 *Root;
	NDT_Index_Id	  Index;
	struct NDT_Node	 *Parent;
	struct NDT_Node	 *Left;
	struct NDT_Node	 *Right;
	void			 *Value;
} NDT_Node;



char ND_Error_Msg [512];



typedef int  NDT_Recursive_Mode;
typedef int  NDT_Recursive_Depth;
typedef int  NDT_Recursive_Offset;

#define NDD_RECURSIVE_MODE_UNKNOWN		(NDT_Recursive_Mode)0x00
#define NDD_RECURSIVE_MODE_PARENT		(NDT_Recursive_Mode)0x01
#define NDD_RECURSIVE_MODE_CHILD		(NDT_Recursive_Mode)0x02
#define NDD_RECURSIVE_MODE_PARENT_CHILD	(NDT_Recursive_Mode)0x03

#define ND_RECURSIVE_PARENT_IS(m)		(m & NDD_RECURSIVE_MODE_PARENT)
#define ND_RECURSIVE_CHILD_IS(m)		(m & NDD_RECURSIVE_MODE_CHILD)

#define ND_RECURSIVE_PRINT_OFFSET       8



/* D<>finition des alias de l'API */

#ifndef ND_MODE
#define ND_MODE     0
#endif

#if ND_MODE == 1 /* API sans v<>rification des arguments */

#define ND_Library_Open             ND_Library_Open_I
#define ND_Library_Close            ND_Library_Close_I
#define ND_Library_Stderr_Set       ND_Library_Stderr_Set_I

#define ND_DataStruct_Open          ND_DataStruct_Open_I
#define ND_DataStruct_Close         ND_DataStruct_Close_I
#define ND_DataStruct_Flush         ND_DataStruct_Flush_I
#define ND_DataStruct_Check         ND_DataStruct_Check_I
#define ND_DataStruct_Convert       ND_DataStruct_Convert_I
#define ND_DataStruct_Reorg         ND_DataStruct_Reorg_I
#define ND_DataStruct_Traverse_V    ND_DataStruct_Traverse_VI
#define ND_DataStruct_Traverse      ND_DataStruct_Traverse_I
#define ND_DataStruct_Info_Print    ND_DataStruct_Info_Print_I
#define ND_DataStruct_Value_Add     ND_DataStruct_Value_Add_I
#define ND_DataStruct_Value_Remove  ND_DataStruct_Value_Remove_I
#define ND_DataStruct_Value_Print   ND_DataStruct_Value_Print_I
#define ND_DataStruct_Value_Find    ND_DataStruct_Value_Find_I

#define ND_Index_Open				ND_Index_Open_I
#define ND_Index_Close				ND_Index_Close_I
#define ND_Index_Flush				ND_Index_Flush_I
#define ND_Index_Check				ND_Index_Check_I
#define ND_Index_Convert			ND_Index_Convert_I
#define ND_Index_Reorg				ND_Index_Reorg_I
#define ND_Index_Traverse_V			ND_Index_Traverse_VI
#define ND_Index_Traverse			ND_Index_Traverse_I
#define ND_Index_Info_Print			ND_Index_Info_Print_I
#define ND_Index_Value_Add			ND_Index_Value_Add_I
#define ND_Index_Value_Remove			ND_Index_Value_Remove_I
#define ND_Index_Value_Print			ND_Index_Value_Print_I
#define ND_Index_Node_Add                 ND_Index_Node_Add_I
#define ND_Index_Node_Remove              ND_Index_Node_Remove_I
#define ND_Index_Node_First_Get           ND_Index_Node_First_Get_I
#define ND_Index_Node_Last_Get            ND_Index_Node_Last_Get_I
#define ND_Index_Node_Next_Get            ND_Index_Node_Next_Get_I
#define ND_Index_Node_Previous_Get        ND_Index_Node_Previous_Get_I
#define ND_Index_Node_Find                ND_Index_Node_Find_I

#define ND_Node_Root_Get            ND_Node_Root_Get_I

#define ND_Value_Alloc              ND_Value_Alloc_I
#define ND_Value_Free               ND_Value_Free_I

#define ND_Manager_Exec_V           ND_Manager_Exec_VI
#define ND_Manager_Exec             ND_Manager_Exec_I
#define ND_Allocator_Exec           ND_Allocator_Exec_I
#define ND_Desallocator_Exec        ND_Desallocator_Exec_I

#else /* API avec v<>rification des arguments */

#define ND_Library_Open             ND_Library_Open_C
#define ND_Library_Close            ND_Library_Close_C
#define ND_Library_Stderr_Set       ND_Library_Stderr_Set_C

#define ND_DataStruct_Open          ND_DataStruct_Open_C
#define ND_DataStruct_Close         ND_DataStruct_Close_C
#define ND_DataStruct_Flush         ND_DataStruct_Flush_C
#define ND_DataStruct_Check         ND_DataStruct_Check_C
#define ND_DataStruct_Convert       ND_DataStruct_Convert_C
#define ND_DataStruct_Reorg         ND_DataStruct_Reorg_C
#define ND_DataStruct_Traverse_V    ND_DataStruct_Traverse_VC
#define ND_DataStruct_Traverse      ND_DataStruct_Traverse_C
#define ND_DataStruct_Info_Print    ND_DataStruct_Info_Print_C
#define ND_DataStruct_Value_Add     ND_DataStruct_Value_Add_C
#define ND_DataStruct_Value_Remove  ND_DataStruct_Value_Remove_C
#define ND_DataStruct_Value_Print   ND_DataStruct_Value_Print_C
#define ND_DataStruct_Value_Find    ND_DataStruct_Value_Find_C

#define ND_Index_Open				ND_Index_Open_C
#define ND_Index_Close				ND_Index_Close_C
#define ND_Index_Flush				ND_Index_Flush_C
#define ND_Index_Check				ND_Index_Check_C
#define ND_Index_Convert			ND_Index_Convert_C
#define ND_Index_Reorg				ND_Index_Reorg_C
#define ND_Index_Traverse_V			ND_Index_Traverse_VC
#define ND_Index_Traverse			ND_Index_Traverse_C
#define ND_Index_Info_Print			ND_Index_Info_Print_C
#define ND_Index_Value_Add			ND_Index_Value_Add_C
#define ND_Index_Value_Remove			ND_Index_Value_Remove_C
#define ND_Index_Value_Print			ND_Index_Value_Print_C
#define ND_Index_Node_Add                 ND_Index_Node_Add_C
#define ND_Index_Node_Remove              ND_Index_Node_Remove_C
#define ND_Index_Node_First_Get           ND_Index_Node_First_Get_C
#define ND_Index_Node_Last_Get            ND_Index_Node_Last_Get_C
#define ND_Index_Node_Next_Get            ND_Index_Node_Next_Get_C
#define ND_Index_Node_Previous_Get        ND_Index_Node_Previous_Get_C
#define ND_Index_Node_Find                ND_Index_Node_Find_C

#define ND_Node_Root_Get            ND_Node_Root_Get_C

#define ND_Value_Alloc              ND_Value_Alloc_C
#define ND_Value_Free               ND_Value_Free_C

#define ND_Manager_Exec_V           ND_Manager_Exec_VC
#define ND_Manager_Exec             ND_Manager_Exec_C
#define ND_Allocator_Exec           ND_Allocator_Exec_C
#define ND_Desallocator_Exec        ND_Desallocator_Exec_C

#endif



/*------------------------------------------------------------------------------*/
/* Initialisation du contexte de la librairie                                   */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Library_Open_I ( int Debug_Mode );
NDT_Status ND_Library_Open_C ( int Debug_Mode );



/*------------------------------------------------------------------------------*/
/* Fermeture du contexte de la librairie                                        */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Library_Close_I( void);
NDT_Status ND_Library_Close_C( void);



/*------------------------------------------------------------------------------*/
/* D<>finition de la sortie standard des messages d'erreur de la librairie       */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Library_Stderr_Set_I( FILE  *Out);
NDT_Status ND_Library_Stderr_Set_C( FILE  *Out);



/*------------------------------------------------------------------------------*/
/* Cr<43>ation d'une nouvelle structure de donn<6E>es                                 */
/*------------------------------------------------------------------------------*/
/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure       */
/* (I) Type: type de la structure.de donn<6E>es (liste ou arbre binaire)           */
/* (I) Allocator: pointeur vers la fonction d'allocation                        */
/* (I) Desallocator: pointeur vers la fonction de d<>sallocation                 */
/* (I) Data : pointeur de donn<6E>es utiles <20> l'allocateur                         */
/* (I) Own_Value : indique si la structure est propri<72>taire de ses valeurs      */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Open_I( NDT_Root  **, NDT_Index_Nb, NDT_Index_Type  *, NDT_Manager_Name, NDT_Manager  *, NDT_Allocator_Name, NDT_Allocator  *, NDT_Desallocator_Name, NDT_Desallocator  *, short, void  *);
NDT_Status ND_DataStruct_Open_C( NDT_Root  **, NDT_Index_Nb, NDT_Index_Type  *, NDT_Manager_Name, NDT_Manager  *, NDT_Allocator_Name, NDT_Allocator  *, NDT_Desallocator_Name, NDT_Desallocator  *, short, void  *);



/*------------------------------------------------------------------------------*/
/* Destruction d'une structure de donn<6E>es                                       */
/*------------------------------------------------------------------------------*/
/* (O) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Close_I( NDT_Root  *Root);
NDT_Status ND_DataStruct_Close_C( NDT_Root  *Root);



/*------------------------------------------------------------------------------*/
/* Destruction d'une structure de donn<6E>es                                       */
/*------------------------------------------------------------------------------*/
/* (O) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Flush_I( NDT_Root  *Root);
NDT_Status ND_DataStruct_Flush_C( NDT_Root  *Root);



/*------------------------------------------------------------------------------*/
/* Function de r<>paration d'une structure :                                     */
/*  - v<>rifie que tous les noeuds sont correctement li<6C>s les uns aux autres     */
/*  - corrige les informations statistiques de la racine                        */
/*------------------------------------------------------------------------------*/
/* (I) Root         : pointeur sur la racine de la structure                    */
/* (O) Nb_Detected  : pointeur sur le nombre d'erreurs                          */
/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs                          */
/* (I) Out          : flux de sortie du rapport                                 */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Check_I( NDT_Root  *Root, int  *Nb_Detected, int  *Nb_Corrected, FILE  *Out);
NDT_Status ND_DataStruct_Check_C( NDT_Root  *Root, int  *Nb_Detected, int  *Nb_Corrected, FILE  *Out);



/*------------------------------------------------------------------------------*/
/* R<>organisation d'une structure de donn<6E>es :                                  */
/*      - ordonnancement d'une liste non ordonn<6E>e                               */
/*      - r<>quilibrage d'un arbre non auto-<2D>quilibr<62>                            */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Reorg_I( NDT_Root  *Root);
NDT_Status ND_DataStruct_Reorg_C( NDT_Root  *Root);



/*------------------------------------------------------------------------------*/
/* Conversion d'une structure de donn<6E>es d'un type en un autre                  */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Target_Type: type de structure cible                                     */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Convert_I( NDT_Root  *, NDT_Index_Type  *);
NDT_Status ND_DataStruct_Convert_C( NDT_Root  *, NDT_Index_Type  *);



/*------------------------------------------------------------------------------*/
/* Parcours de tous les noeuds d'une structure de donn<6E>es et ex<65>cution d'une    */
/* commande sur chacun d'eux                                                    */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Command: Commande <20> ex<65>cuter sur chaque noeud travers<72>                   */
/* (I) Data: pointeur de donn<6E>es utilisateur                                    */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Traverse_VI( NDT_Root  *, NDT_Command  Command, va_list);
NDT_Status ND_DataStruct_Traverse_VC( NDT_Root  *, NDT_Command  Command, va_list);
NDT_Status ND_DataStruct_Traverse_I( NDT_Root  *, NDT_Command  Command, ...);
NDT_Status ND_DataStruct_Traverse_C( NDT_Root  *, NDT_Command  Command, ...);



/*------------------------------------------------------------------------------*/
/* Affichage d'informations sur une structure de donn<6E>es                        */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Out : flux de sortie                                                     */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Info_Print_I( FILE  *, NDT_Root  *Root, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset);
NDT_Status ND_DataStruct_Info_Print_C( FILE  *, NDT_Root  *Root, NDT_Recursive_Mode  Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset);



/*------------------------------------------------------------------------------*/
/* Ajout d'une valeur <20> une structure de donn<6E>es                                */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Value: pointeur sur la valeur <20> ajouter                                  */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Value_Add_I( NDT_Root  *Root, void  *Value);
NDT_Status ND_DataStruct_Value_Add_C( NDT_Root  *Root, void  *Value);



/*------------------------------------------------------------------------------*/
/* Suppression du premier noeud correspondant <20> une valeur donn<6E>e               */
/*------------------------------------------------------------------------------*/
/* (I) Root            : pointeur sur la racine de la structure de donn<6E>es      */
/* (I) Reference_Value : pointeur sur la valeur de r<>f<EFBFBD>rence                    */
/* (I) Removed_Value   : adresse d'un pointeur sur la valeur supprim<69>e          */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Value_Remove_I( NDT_Root  *Root, void  *Value);
NDT_Status ND_DataStruct_Value_Remove_C( NDT_Root  *Root, void  *Value);



/*------------------------------------------------------------------------------*/
/* Affichage de la valeur de tous les noeuds d'une structure de donn<6E>es         */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Out : flux de sortie                                                     */
/*------------------------------------------------------------------------------*/
NDT_Status ND_DataStruct_Value_Print_VI( FILE  *, NDT_Root  *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, va_list);
NDT_Status ND_DataStruct_Value_Print_I( FILE  *, NDT_Root  *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...);
NDT_Status ND_DataStruct_Value_Print_C( FILE  *, NDT_Root  *, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...);



/*------------------------------------------------------------------------------*/
/* Recherche un noeud <20> partir d'une valeur                                     */
/*------------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de l'abre                                  */
/* (O) Node : pointeur sur le noeud <20> r<>cuperer                                 */
/* (I) Value  : pointeur sur la valeur <20> rechercher                             */
/* (I) Data  : pointeur de donn<6E>es                                              */
/*------------------------------------------------------------------------------*/

NDT_Status  ND_DataStruct_Value_Find_VI( void  **Value_Ptr_Ptr, NDT_Root  *Root_Ptr, void  *Ref_Value_Ptr, va_list);
NDT_Status  ND_DataStruct_Value_Find_VC( void  **Value_Ptr_Ptr, NDT_Root  *Root_Ptr, void  *Ref_Value_Ptr, va_list);
NDT_Status  ND_DataStruct_Value_Find_I( void  **Value_Ptr_Ptr, NDT_Root  *Root_Ptr, void  *Ref_Value_Ptr, ...);
NDT_Status  ND_DataStruct_Value_Find_C( void  **Value_Ptr_Ptr, NDT_Root  *Root_Ptr, void  *Ref_Value_Ptr, ...);



/*------------------------------------------------------------------------------*/
/* Create a new index (not yet implemented !)                                   */
/*------------------------------------------------------------------------------*/
/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure       */
/* (I) Type: type de la structure.de donn<6E>es (liste ou arbre binaire)           */
/* (I) Allocator: pointeur vers la fonction d'allocation                        */
/* (I) Desallocator: pointeur vers la fonction de d<>sallocation                 */
/* (I) Data : pointeur de donn<6E>es utiles <20> l'allocateur                         */
/* (I) Own_Value : indique si la structure est propri<72>taire de ses valeurs      */
/*------------------------------------------------------------------------------*/
NDT_Status  ND_Index_Open_I( NDT_Root  *, NDT_Index_Id, NDT_Index_Type);
NDT_Status  ND_Index_Open_C( NDT_Root  *, NDT_Index_Id, NDT_Index_Type);



/*------------------------------------------------------------------------------*/
/* Remove an Index (not yet implemented !)                                      */
/*------------------------------------------------------------------------------*/
/* (O) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/*------------------------------------------------------------------------------*/
NDT_Status  ND_Index_Close_I( NDT_Root  *, NDT_Index_Id);
NDT_Status  ND_Index_Close_C( NDT_Root  *, NDT_Index_Id);



/*------------------------------------------------------------------------------*/
/* Remove an Index (not yet implemented !)                                      */
/*------------------------------------------------------------------------------*/
/* (O) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/*------------------------------------------------------------------------------*/
NDT_Status  ND_Index_Flush_I( NDT_Root  *, NDT_Index_Id);
NDT_Status  ND_Index_Flush_C( NDT_Root  *, NDT_Index_Id);



/*------------------------------------------------------------------------------*/
/* Function de r<>paration d'une structure :                                     */
/*  - v<>rifie que tous les noeuds sont correctement li<6C>s les uns aux autres     */
/*  - corrige les informations statistiques de la racine                        */
/*------------------------------------------------------------------------------*/
/* (I) Root         : pointeur sur la racine de la structure                    */
/* (O) Nb_Detected  : pointeur sur le nombre d'erreurs                          */
/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs                          */
/* (I) Out          : flux de sortie du rapport                                 */
/*------------------------------------------------------------------------------*/
NDT_Status  ND_Index_Check_I( NDT_Root  *Root, NDT_Index_Id, int  *, int  *, FILE  *);
NDT_Status  ND_Index_Check_C( NDT_Root  *Root, NDT_Index_Id, int  *, int  *, FILE  *);



/*------------------------------------------------------------------------------*/
/* Conversion d'une structure de donn<6E>es d'un type en un autre                  */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Target_Type: type de structure cible                                     */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Index_Convert_I ( NDT_Root  *, NDT_Index_Id  Index_Id, NDT_Index_Type);
NDT_Status ND_Index_Convert_C ( NDT_Root  *, NDT_Index_Id  Index_Id, NDT_Index_Type);



/*------------------------------------------------------------------------------*/
/* R<>organisation d'une structure de donn<6E>es :                                  */
/*      - ordonnancement d'une liste non ordonn<6E>e                               */
/*      - r<>quilibrage d'un arbre non auto-<2D>quilibr<62>                            */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/*------------------------------------------------------------------------------*/
NDT_Status  ND_Index_Reorg_I( NDT_Root  *, NDT_Index_Id);
NDT_Status  ND_Index_Reorg_C( NDT_Root  *, NDT_Index_Id);



/*------------------------------------------------------------------------------*/
/* Parcours de tous les noeuds d'une structure de donn<6E>es et ex<65>cution d'une    */
/* commande sur chacun d'eux                                                    */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Command: Commande <20> ex<65>cuter sur chaque noeud travers<72>                   */
/* (I) Data: pointeur de donn<6E>es utilisateur                                    */
/*------------------------------------------------------------------------------*/
NDT_Status  ND_Index_Traverse_VI( NDT_Root  *, NDT_Index_Id, NDT_Command, va_list);
NDT_Status  ND_Index_Traverse_VC( NDT_Root  *, NDT_Index_Id, NDT_Command, va_list);
NDT_Status  ND_Index_Traverse_I( NDT_Root  *, NDT_Index_Id, NDT_Command, ...);
NDT_Status  ND_Index_Traverse_C( NDT_Root  *, NDT_Index_Id, NDT_Command, ...);



/*------------------------------------------------------------------------------*/
/* Parcours de tous les noeuds d'une structure de donn<6E>es et ex<65>cution d'une    */
/* commande sur chacun d'eux                                                    */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Command: Commande <20> ex<65>cuter sur chaque noeud travers<72>                   */
/* (I) Data: pointeur de donn<6E>es utilisateur                                    */
/*------------------------------------------------------------------------------*/
NDT_Status  ND_Index_Info_Print_I( FILE  *, NDT_Root  *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset);
NDT_Status  ND_Index_Info_Print_C( FILE  *, NDT_Root  *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset);



/*------------------------------------------------------------------------------*/
/* Ajout d'une valeur <20> une structure de donn<6E>es                                */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Value: pointeur sur la valeur <20> ajouter                                  */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Index_Value_Add_I( NDT_Root  *Root, NDT_Index_Id, void  *Value);
NDT_Status ND_Index_Value_Add_C( NDT_Root  *Root, NDT_Index_Id, void  *Value);



/*------------------------------------------------------------------------------*/
/* Suppression du premier noeud correspondant <20> une valeur donn<6E>e               */
/*------------------------------------------------------------------------------*/
/* (I) Root            : pointeur sur la racine de la structure de donn<6E>es      */
/* (I) Reference_Value : pointeur sur la valeur de r<>f<EFBFBD>rence                    */
/* (I) Removed_Value   : adresse d'un pointeur sur la valeur supprim<69>e          */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Index_Value_Remove_I( NDT_Root  *Root, NDT_Index_Id, void  *Value);
NDT_Status ND_Index_Value_Remove_C( NDT_Root  *Root, NDT_Index_Id, void  *Value);



/*------------------------------------------------------------------------------*/
/* Affichage de la valeur de tous les noeuds d'une structure de donn<6E>es         */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Out : flux de sortie                                                     */
/*------------------------------------------------------------------------------*/
NDT_Status  ND_Index_Value_Print_VI( FILE  *, NDT_Root  *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, va_list);
NDT_Status  ND_Index_Value_Print_I( FILE  *, NDT_Root  *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...);
NDT_Status  ND_Index_Value_Print_C( FILE  *, NDT_Root  *, NDT_Index_Id, NDT_Recursive_Mode, NDT_Recursive_Depth, NDT_Recursive_Offset, ...);



/*------------------------------------------------------------------------------*/
/* Ajout d'un noeud <20> une structure de donn<6E>es                                  */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Node: pointeur sur le noeud <20> ajouter                                    */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Index_Node_Add_I( NDT_Root * Root, NDT_Index_Id  Index_Id, NDT_Node * Node );
NDT_Status ND_Index_Node_Add_C( NDT_Root * Root, NDT_Index_Id  Index_Id, NDT_Node * Node );



/*------------------------------------------------------------------------------*/
/* Suppression d'un noeud dans une structure de donn<6E>es                         */
/*------------------------------------------------------------------------------*/
/* (I) Node: pointeur sur le noeud <20> supprimer de la structure de donn<6E>es       */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Index_Node_Remove_I( NDT_Node * Node);
NDT_Status ND_Index_Node_Remove_C( NDT_Node * Node);



/*------------------------------------------------------------------------------*/
/* R<>cup<75>ration du premier noeud d'une structure                                */
/*------------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine dont on cherche le premier noeud           */
/* (O) Node : pointeur sur le noeud <20> r<>cup<75>rer                                 */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Index_Node_First_Get_I( NDT_Node  **, NDT_Root  *, NDT_Index_Id);
NDT_Status ND_Index_Node_First_Get_C( NDT_Node  **, NDT_Root  *, NDT_Index_Id);



/*------------------------------------------------------------------------------*/
/* R<>cup<75>ration du dernier noeud d'une structure                                */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine dont on cherche le dernier noeud            */
/* (O) Node : pointeur sur le noeud <20> r<>cup<75>rer                                 */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Index_Node_Last_Get_I( NDT_Node  **, NDT_Root  *, NDT_Index_Id);
NDT_Status ND_Index_Node_Last_Get_C( NDT_Node  **, NDT_Root  *, NDT_Index_Id);



/*------------------------------------------------------------------------------*/
/* R<>cup<75>ration du noeud suivant                                                */
/*------------------------------------------------------------------------------*/
/* (I) Node: pointeur sur le noeud dont on cherche le suivant                   */
/* (O) Next_Node : pointeur sur le noeud suivant                                */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Index_Node_Next_Get_I( NDT_Node  **, NDT_Node  *);
NDT_Status ND_Index_Node_Next_Get_C( NDT_Node  **, NDT_Node  *);



/*------------------------------------------------------------------------------*/
/* R<>cup<75>ration du noeud pr<70>c<EFBFBD>dant                                              */
/*------------------------------------------------------------------------------*/
/* (I) Node: pointeur sur le noeud dont on cherche le pr<70>c<EFBFBD>dant                 */
/* (O) Prev_Node : pointeur sur le noeud pr<70>c<EFBFBD>dant                              */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Index_Node_Previous_Get_I( NDT_Node  **, NDT_Node  *);
NDT_Status ND_Index_Node_Previous_Get_C( NDT_Node  **, NDT_Node  *);



/*------------------------------------------------------------------------------*/
/* Recherche un noeud <20> partir d'une valeur                                     */
/*------------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de l'abre                                  */
/* (O) Node : pointeur sur le noeud <20> r<>cuperer                                 */
/* (I) Value  : pointeur sur la valeur <20> rechercher                             */
/* (I) Data  : pointeur de donn<6E>es                                              */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Index_Node_Find_VI( NDT_Node  **, NDT_Root  *, NDT_Index_Id, void  *, va_list);
NDT_Status ND_Index_Node_Find_VC( NDT_Node  **, NDT_Root  *, NDT_Index_Id, void  *, va_list);
NDT_Status ND_Index_Node_Find_I( NDT_Node  **, NDT_Root  *, NDT_Index_Id, void  *, ...);
NDT_Status ND_Index_Node_Find_C( NDT_Node  **, NDT_Root  *, NDT_Index_Id, void  *, ...);



/*------------------------------------------------------------------------------*/
/* R<>cup<75>ration de la racine d'une structure                                    */
/*------------------------------------------------------------------------------*/
/* (O) Root: Adresse du pointeur sur la racine <20> r<>cup<75>rer                      */
/* (I) Node: pointeur sur le noeud dont on cherche la racine                    */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Node_Root_Get_I( NDT_Root  **, NDT_Node  *);
NDT_Status ND_Node_Root_Get_C( NDT_Root  **, NDT_Node  *);



/*------------------------------------------------------------------------------*/
/* Allocation d'une valeur d'une structure de donn<6E>es                           */
/*------------------------------------------------------------------------------*/
/* (I) Root  : pointeur sur la racine de la structure de donn<6E>es                */
/* (O) Value : adresse d'un pointeur sur la valeur <20> allouer                    */
/* (I) ...   : arguments relatifs <20> l'allocation de la valeur                   */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Value_Alloc_I( NDT_Root  *, void  **, ...);
NDT_Status ND_Value_Alloc_C( NDT_Root  *, void  **, ...);



/*------------------------------------------------------------------------------*/
/* D<>sallocation d'une valeur d'une structure de donn<6E>es                        */
/*------------------------------------------------------------------------------*/
/* (I) Root: pointeur sur la racine de la structure de donn<6E>es                  */
/* (I) Value: pointeur sur la valeur <20> d<>sallouer                               */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Value_Free_I( NDT_Root  *, void  *);
NDT_Status ND_Value_Free_C( NDT_Root  *, void  *);



/*------------------------------------------------------------------------------*/
/* Ex<45>cution d'une fonction Manager dont le nom est pass<73> en param<61>tre          */
/*------------------------------------------------------------------------------*/
/* (I) Function : nom de la fonction manager <20> ex<65>cuter                         */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Manager_Exec_VI( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
NDT_Status ND_Manager_Exec_VC( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);
NDT_Status ND_Manager_Exec_I( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, ...);
NDT_Status ND_Manager_Exec_C( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, ...);



/*------------------------------------------------------------------------------*/
/* Ex<45>cution d'une fonction d'allocation dont le nom est pass<73> en param<61>tre     */
/*------------------------------------------------------------------------------*/
/* (I) Function : nom de la fonction <20> ex<65>cuter                                 */
/* (O) Ptr : adresse d'un pointeur sur la zone <20> allouer                        */
/* (I) Size : taille de la zone <20> allouer                                       */
/* (I) Data : pointeur de donn<6E>es utiles <20> l'allocateur                         */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Allocator_Exec_I( NDT_Allocator  *, void  **, size_t, void  *);
NDT_Status ND_Allocator_Exec_C( NDT_Allocator  *, void  **, size_t, void  *);



/*------------------------------------------------------------------------------*/
/* Ex<45>cution d'une fonction de d<>sallocation le dont nom est pass<73> en param<61>tre */
/*------------------------------------------------------------------------------*/
/* (I) Function : nom de la fonction <20> ex<65>cuter                                 */
/* (I) Ptr : adresse de la zone <20> d<>sallouer                                    */
/* (I) Data : pointeur de donn<6E>es utiles au d<>sallocateur                       */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Desallocator_Exec_I( NDT_Desallocator  *, void  *, void  *);
NDT_Status ND_Desallocator_Exec_C( NDT_Desallocator  *, void  *, void  *);



#ifdef __cplusplus
}
#endif

#endif