462 lines
25 KiB
C
462 lines
25 KiB
C
#ifndef _LIBNODE
|
|
#define _LIBNODE
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stdarg.h>
|
|
#include <ver.h>
|
|
|
|
#ifndef TRUE
|
|
#define TRUE 1
|
|
#endif
|
|
|
|
#ifndef FALSE
|
|
#define FALSE 0
|
|
#endif
|
|
|
|
/*
|
|
Différence de profondeur entre la branche la plus courte et
|
|
la plus longue d'un arbre.
|
|
Le dépassement de ce seuil provoque le rééquilibrage de l'arbre
|
|
*/
|
|
|
|
#define DEF_MAX_DIF 100
|
|
|
|
/* Types de structure */
|
|
|
|
typedef int NDT_DataStruct_Type;
|
|
|
|
#define NDD_DS_LIST 0001 /* liste chaînée */
|
|
#define NDD_DS_TREE 0002 /* arbre binaire */
|
|
#define NDD_DS_MSK (NDD_DS_LIST | NDD_DS_TREE)
|
|
|
|
#define ND_IS_LIST(r) ((r)->Type & NDD_DS_LIST)
|
|
#define ND_IS_TREE(r) ((r)->Type & NDD_DS_TREE)
|
|
|
|
#define NDD_MN_FIFO 0010 /* principe de la file d'attente (First In First Out) */
|
|
#define NDD_MN_LILO NDD_MN_FIFO
|
|
#define NDD_MN_FILO 0020 /* principe de la pile (First In Last Out) */
|
|
#define NDD_MN_LIFO NDD_MN_FILO
|
|
#define NDD_MN_ORDERED 0040 /* liste triée */
|
|
#define NDD_MN_AUTO_EQU 0100 /* arbre auto-équilibré */
|
|
#define NDD_MN_MSK (NDD_MN_FIFO | NDD_MN_FILO | NDD_MN_ORDERED | NDD_MN_AUTO_EQU)
|
|
|
|
#define ND_IS_FIFO(r) ((r)->Type & NDD_MN_FIFO)
|
|
#define ND_IS_FILO(r) ((r)->Type & NDD_MN_FILO)
|
|
#define ND_IS_ORDERED(r) ((r)->Type & NDD_MN_ORDERED)
|
|
#define ND_IS_AUTO_EQU(r) ((r)->Type & NDD_MN_AUTO_EQU)
|
|
|
|
/* Commandes du manager */
|
|
|
|
typedef int NDT_Command;
|
|
|
|
#define NDD_CMD_MAKE_VALUE 1
|
|
#define NDD_CMD_COMP_VALUE 2
|
|
#define NDD_CMD_SUM_VALUES 3
|
|
#define NDD_CMD_PRINT_VALUE 4
|
|
#define NDD_CMD_DELETE_VALUE 5
|
|
#define NDD_CMD_PRINT_INFO 6
|
|
|
|
/* Types de réponse du manager ou code retour des diverses fonctions */
|
|
|
|
typedef int NDT_Status;
|
|
|
|
#define ND_ERROR(s) ((s) < 0) /* Tous les codes retour négatifs correspondent à des erreurs */
|
|
|
|
#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ème d'allocation mémoire */
|
|
#define NDS_ERRAPI -2 /* Utilisation incorrecte des API */
|
|
|
|
/* Pointeur de fonction sur le manager */
|
|
|
|
typedef NDT_Status NDT_Manager (va_list);
|
|
|
|
/* Pointeur de fonction sur l'allocateur */
|
|
|
|
typedef NDT_Status NDT_Allocator (size_t, void **, void *);
|
|
|
|
/* Pointeur de fonction sur le désallocateur */
|
|
|
|
typedef NDT_Status NDT_Desallocator (void *, void *);
|
|
|
|
/* Structure racine */
|
|
|
|
typedef struct NDT_Root {
|
|
NDT_DataStruct_Type Type; /* Type de la structure (liste, arbre ... ) */
|
|
long Node_Number; /* Nombre de noeuds dans la structure */
|
|
long Min_Depth; /* Profondeur minimale de l'arbre */
|
|
long Max_Depth; /* Profondeur maximale de l'arbre */
|
|
long Max_Dif; /* Différence maximale autorisée entre la branche la plus courte et la plus longue */
|
|
long Nb_Equ; /* Nombre de réquilibrages réalisés sur l'arbre */
|
|
char Manager [50]; /* Nom de la fonction manager */
|
|
char Allocator [50]; /* Nom de la fonction d'allocation */
|
|
char Desallocator [50]; /* Nom de la fonction de désallocation */
|
|
struct NDT_Node * Head; /* Noeud de tête */
|
|
struct NDT_Node * Queue; /* Noeud de queue */
|
|
struct NDT_Node * Save; /* Pointeur de sauvegarde (utile pour la fonction de restauration) */
|
|
void * User; /* Pointeur utilisable librement par l'utilisateur */
|
|
short int Own_Value; /* Indique si la structure est propriétaire de ses valeurs */
|
|
} NDT_Root;
|
|
|
|
/* Structure de noeud */
|
|
|
|
typedef struct NDT_Node {
|
|
struct NDT_Root * Root;
|
|
struct NDT_Node * Parent;
|
|
struct NDT_Node * Left;
|
|
struct NDT_Node * Right;
|
|
void * Value;
|
|
} NDT_Node;
|
|
|
|
char ND_Error_Msg [512];
|
|
|
|
/* 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_Reorg ND_DataStruct_Reorg_I
|
|
#define ND_DataStruct_Traverse ND_DataStruct_Traverse_I
|
|
#define ND_DataStruct_Convert ND_DataStruct_Convert_I
|
|
#define ND_DataStruct_Info_Print ND_DataStruct_Info_Print_I
|
|
#define ND_DataStruct_Print ND_DataStruct_Print_I
|
|
#define ND_DataStruct_Check ND_DataStruct_Check_I
|
|
#define ND_DataStruct_Dump ND_DataStruct_Dump_I
|
|
#define ND_Node_Root_Get ND_Node_Root_Get_I
|
|
#define ND_Node_First_Get ND_Node_First_Get_I
|
|
#define ND_Node_Last_Get ND_Node_Last_Get_I
|
|
#define ND_Node_Next_Get ND_Node_Next_Get_I
|
|
#define ND_Node_Previous_Get ND_Node_Previous_Get_I
|
|
#define ND_Node_Add ND_Node_Add_I
|
|
#define ND_Node_Remove ND_Node_Remove_I
|
|
#define ND_Node_Find ND_Node_Find_I
|
|
#define ND_Value_Alloc ND_Value_Alloc_I
|
|
#define ND_Value_Add ND_Value_Add_I
|
|
#define ND_Value_Remove ND_Value_Remove_I
|
|
#define ND_Value_Free ND_Value_Free_I
|
|
#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_Reorg ND_DataStruct_Reorg_C
|
|
#define ND_DataStruct_Traverse ND_DataStruct_Traverse_C
|
|
#define ND_DataStruct_Convert ND_DataStruct_Convert_C
|
|
#define ND_DataStruct_Info_Print ND_DataStruct_Info_Print_C
|
|
#define ND_DataStruct_Print ND_DataStruct_Print_C
|
|
#define ND_DataStruct_Check ND_DataStruct_Check_C
|
|
#define ND_DataStruct_Dump ND_DataStruct_Dump_C
|
|
#define ND_Node_Root_Get ND_Node_Root_Get_C
|
|
#define ND_Node_First_Get ND_Node_First_Get_C
|
|
#define ND_Node_Last_Get ND_Node_Last_Get_C
|
|
#define ND_Node_Next_Get ND_Node_Next_Get_C
|
|
#define ND_Node_Previous_Get ND_Node_Previous_Get_C
|
|
#define ND_Node_Add ND_Node_Add_C
|
|
#define ND_Node_Remove ND_Node_Remove_C
|
|
#define ND_Node_Find ND_Node_Find_C
|
|
#define ND_Value_Alloc ND_Value_Alloc_C
|
|
#define ND_Value_Add ND_Value_Add_C
|
|
#define ND_Value_Remove ND_Value_Remove_C
|
|
#define ND_Value_Free ND_Value_Free_C
|
|
#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éation d'une nouvelle structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (O) Root: adresse d'un pointeur sur la racine de la nouvelle structure */
|
|
/* (I) Type: type de la structure.de donné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ées utiles à l'allocateur */
|
|
/* (I) Own_Value : indique si la structure est propriétaire de ses valeurs */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_DataStruct_Open_I ( NDT_Root ** Root, NDT_DataStruct_Type Type, \
|
|
const char * Allocator, \
|
|
const char * Desallocator, \
|
|
void * Data, int Own_Value );
|
|
NDT_Status ND_DataStruct_Open_C ( NDT_Root ** Root, NDT_DataStruct_Type Type, \
|
|
const char * Allocator, \
|
|
const char * Desallocator, \
|
|
void * Data, int Own_Value );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Destruction d'une structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (O) Root: pointeur sur la racine de la structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_DataStruct_Close_I ( NDT_Root * Root );
|
|
NDT_Status ND_DataStruct_Close_C ( NDT_Root * Root );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Réorganisation d'une structure de données : */
|
|
/* - ordonnancement d'une liste non ordonnée */
|
|
/* - réquilibrage d'un arbre non auto-équilibré */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root: pointeur sur la racine de la structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_DataStruct_Reorg_I ( NDT_Root * Root );
|
|
NDT_Status ND_DataStruct_Reorg_C ( NDT_Root * Root );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Parcours de tous les noeuds d'une structure de données et exécution d'une */
|
|
/* commande sur chacun d'eux */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root: pointeur sur la racine de la structure de données */
|
|
/* (I) Command: Commande à exécuter sur chaque noeud traversé */
|
|
/* (I) Data: pointeur de données utilisateur */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_DataStruct_Traverse_I ( NDT_Root * Root, NDT_Command Command, \
|
|
void * Data );
|
|
NDT_Status ND_DataStruct_Traverse_C ( NDT_Root * Root, NDT_Command Command, \
|
|
void * Data );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Conversion d'une structure de données d'un type en un autre */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root: pointeur sur la racine de la structure de données */
|
|
/* (I) Target_Type: type de structure cible */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_DataStruct_Convert_I ( NDT_Root * Root, \
|
|
NDT_DataStruct_Type Target_Type );
|
|
NDT_Status ND_DataStruct_Convert_C ( NDT_Root * Root, \
|
|
NDT_DataStruct_Type Target_Type );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Affichage d'informations sur une structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root: pointeur sur la racine de la structure de données */
|
|
/* (I) Out : flux de sortie */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_DataStruct_Info_Print_I ( NDT_Root * Root, FILE * Out );
|
|
NDT_Status ND_DataStruct_Info_Print_C ( NDT_Root * Root, FILE * Out );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Affichage de la valeur de tous les noeuds d'une structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root: pointeur sur la racine de la structure de données */
|
|
/* (I) Out : flux de sortie */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_DataStruct_Print_I ( NDT_Root * Root, FILE * Out );
|
|
NDT_Status ND_DataStruct_Print_C ( NDT_Root * Root, FILE * Out );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Function de réparation d'une structure : */
|
|
/* - vérifie que tous les noeuds sont correctement lié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 );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Affiche la structure de données et ses informations statistiques */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root : pointeur sur la racine de la structure */
|
|
/* (I) Out : flux de sortie */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_DataStruct_Dump_I ( NDT_Root * Root, FILE * Out );
|
|
NDT_Status ND_DataStruct_Dump_C ( NDT_Root * Root, FILE * Out );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Récupération de la racine d'une structure */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (O) Root: Adresse du pointeur sur la racine à récupérer */
|
|
/* (I) Node: pointeur sur le noeud dont on cherche la racine */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Node_Root_Get_I ( NDT_Root ** Root, NDT_Node * Node );
|
|
NDT_Status ND_Node_Root_Get_C ( NDT_Root ** Root, NDT_Node * Node );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Récupé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 à récupérer */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Node_First_Get_I ( NDT_Root * Root, NDT_Node ** Node );
|
|
NDT_Status ND_Node_First_Get_C ( NDT_Root * Root, NDT_Node ** Node );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Récupé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 à récupérer */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Node_Last_Get_I ( NDT_Root * Root, NDT_Node ** Node );
|
|
NDT_Status ND_Node_Last_Get_C ( NDT_Root * Root, NDT_Node ** Node );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Récupé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_Node_Next_Get_I ( NDT_Node * Node, NDT_Node ** Next_Node );
|
|
NDT_Status ND_Node_Next_Get_C ( NDT_Node * Node, NDT_Node ** Next_Node );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Récupération du noeud précédant */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Node: pointeur sur le noeud dont on cherche le précédant */
|
|
/* (O) Prev_Node : pointeur sur le noeud précédant */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Node_Previous_Get_I ( NDT_Node * Node, NDT_Node **Prev_Node );
|
|
NDT_Status ND_Node_Previous_Get_C ( NDT_Node * Node, NDT_Node **Prev_Node );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Ajout d'un noeud à une structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root: pointeur sur la racine de la structure de données */
|
|
/* (I) Node: pointeur sur le noeud à ajouter */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Node_Add_I ( NDT_Root * Root, NDT_Node * Node );
|
|
NDT_Status ND_Node_Add_C ( NDT_Root * Root, NDT_Node * Node );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Suppression d'un noeud dans une structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Node: pointeur sur le noeud à supprimer de la structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Node_Remove_I ( NDT_Node * Node);
|
|
NDT_Status ND_Node_Remove_C ( NDT_Node * Node);
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Recherche un noeud à partir d'une valeur */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root : pointeur sur la racine de l'abre */
|
|
/* (O) Node : pointeur sur le noeud à récuperer */
|
|
/* (I) Value : pointeur sur la valeur à rechercher */
|
|
/* (I) Data : pointeur de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Node_Find_I ( NDT_Root * Root, NDT_Node ** Node, void * Value, void * Data );
|
|
NDT_Status ND_Node_Find_C ( NDT_Root * Root, NDT_Node ** Node, void * Value, void * Data );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Allocation d'une valeur d'une structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root : pointeur sur la racine de la structure de données */
|
|
/* (O) Value : adresse d'un pointeur sur la valeur à allouer */
|
|
/* (I) ... : arguments relatifs à l'allocation de la valeur */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Value_Alloc_I ( NDT_Root * Root, void ** Value, ... );
|
|
NDT_Status ND_Value_Alloc_C ( NDT_Root * Root, void ** Value, ... );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Ajout d'une valeur à une structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root: pointeur sur la racine de la structure de données */
|
|
/* (I) Value: pointeur sur la valeur à ajouter */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Value_Add_I ( NDT_Root * Root, void * Value );
|
|
NDT_Status ND_Value_Add_C ( NDT_Root * Root, void * Value );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Suppression du premier noeud correspondant à une valeur donnée */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root : pointeur sur la racine de la structure de données */
|
|
/* (I) Reference_Value : pointeur sur la valeur de référence */
|
|
/* (I) Removed_Value : adresse d'un pointeur sur la valeur supprimée */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Value_Remove_I ( NDT_Root * Root, void * Reference_Value, void ** Removed_Value );
|
|
NDT_Status ND_Value_Remove_C ( NDT_Root * Root, void * Reference_Value, void ** Removed_Value );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Désallocation d'une valeur d'une structure de données */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Root: pointeur sur la racine de la structure de données */
|
|
/* (I) Value: pointeur sur la valeur à désallouer */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Value_Free_I ( NDT_Root * Root, void * Value );
|
|
NDT_Status ND_Value_Free_C ( NDT_Root * Root, void * Value );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Exécution d'une fonction Manager dont le nom est passé en paramètre */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Function : nom de la fonction manager à exécuter */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Manager_Exec_I ( const char * Function, ... );
|
|
NDT_Status ND_Manager_Exec_C ( const char * Function, ... );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Exécution d'une fonction d'allocation dont le nom est passé en paramètre */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Function : nom de la fonction à exécuter */
|
|
/* (O) Ptr : adresse d'un pointeur sur la zone à allouer */
|
|
/* (I) Size : taille de la zone à allouer */
|
|
/* (I) Data : pointeur de données utiles à l'allocateur */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Allocator_Exec_I ( const char * Function, void ** Ptr, \
|
|
size_t Size, void * Data );
|
|
NDT_Status ND_Allocator_Exec_C ( const char * Function, void ** Ptr, \
|
|
size_t Size, void * Data );
|
|
|
|
/*------------------------------------------------------------------------------*/
|
|
/* Exécution d'une fonction de désallocation le dont nom est passé en paramètre */
|
|
/*------------------------------------------------------------------------------*/
|
|
/* (I) Function : nom de la fonction à exécuter */
|
|
/* (I) Ptr : adresse de la zone à désallouer */
|
|
/* (I) Data : pointeur de données utiles au désallocateur */
|
|
/*------------------------------------------------------------------------------*/
|
|
NDT_Status ND_Desallocator_Exec_I ( const char * Function, void * Ptr, \
|
|
void * Data );
|
|
NDT_Status ND_Desallocator_Exec_C ( const char * Function, void * Ptr, \
|
|
void * Data );
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|