/*----------------------------------------------------------------------------*/
/* libnode.h */
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* This file is part of LibNode */
/* */
/* LibNode is free software: you can redistribute it and/or modify it */
/* under the terms of the GNU Lesser General Public License as published */
/* by the Free Software Foundation, either version 3 of the License, or */
/* (at your option) any later version. */
/* */
/* LibNode is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU Lesser General Public License for more details. */
/* */
/* You should have received a copy of the GNU Lesser General Public */
/* License along with LibNode. If not, see */
/* . */
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* Includes */
/*----------------------------------------------------------------------------*/
#include
#include
#include
#include
#include
#include
#include
/* Utilisation des API de la LIBNODE sans vérification des arguments */
#define ND_MODE 1
#include
/*----------------------------------------------------------------------------*/
/* Definitions */
/*----------------------------------------------------------------------------*/
#define LGD_MODULE_NAME "nd"
#ifdef __linux
# define NDD_PRINTF_PTR_PREFIX ""
#else
# define NDD_PRINTF_PTR_PREFIX "0x"
#endif
#define NDD_HUGE_LONG ( long) 0xFFFFFFL
/* Table des symboles locale */
struct NDT_Symbol;
typedef struct NDT_Symbol
{
void *Ptr;
char *Name;
struct NDT_Symbol *Next;
} NDT_Symbol;
/* LibNode Global Base Structure */
typedef struct NDT_Base
{
int Open_Status;
int Debug_Mode;
char Err_String[512];
FILE *Err_Stream;
int Sig_Trapped;
#if !defined(_WIN32)
sigjmp_buf SigLongJmp_Env;
#else
jmp_buf SigLongJmp_Env;
#endif
NDT_Symbol *Symbol_First_Ptr;
void *DL_Ptr;
NDT_Index_Type OpenStruct_Index_Type[1];
NDT_Root *OpenStruct_Ptr;
} NDT_Base;
NDT_Base NDG_Base =
{
NDD_FALSE,
NDD_TRUE,
"",
(FILE *) -1,
0,
{0},
(NDT_Symbol *) NULL,
NULL,
{ NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO},
(NDT_Root *) NULL
};
/*------------------------------------------------------------------------------*/
/* */
/*------------------------------------------------------------------------------*/
#define ND_LIBNODE_OPEN_CHECK() if( NDG_Base.Open_Status != NDD_TRUE) { LG_LOG_ERROR_0( "LibNode library is not opened"); return( NDS_ERRAPI); }
#define ND_NOT_NULL_CHECK( Ptr, Msg) if( !( Ptr)) { LG_LOG_ERROR_1( "%s is null", ( Msg)); return( NDS_ERRAPI); }
#define ND_HANDLER_NOT_NULL_CHECK( Function_Name, Function_Ptr) if( ( !( Function_Name)) && ( !( Function_Ptr))) { LG_LOG_ERROR_0( "Undefined function name"); return( NDS_ERRAPI); }
#define ND_HANDLER_SYMBOL_FIND( Function_Ptr, Handler_Name, Handler_Ptr) if( ( Handler_Ptr)) { ( Function_Ptr) = ( Handler_Ptr);} \
else { if( ND_Symbol_Find( (void **)&( Function_Ptr), ( Handler_Name)) != NDS_OK) { LG_LOG_ERROR_0( "Cant't find free handler function"); return( NDS_KO);}}
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* Fonctions et procédures privées de la librairie (moyen niveau) */
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* Manager par défaut */
/*----------------------------------------------------------------------------*/
/* (I) va_list Arguments : Liste d'arguments contextuels */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Default_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *);
/*----------------------------------------------------------------------------*/
/* OpenStruct Manager */
/*----------------------------------------------------------------------------*/
/* (I) va_list Arguments : Liste d'arguments contextuels */
/*----------------------------------------------------------------------------*/
NDT_Status ND_OpenStruct_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *);
/*----------------------------------------------------------------------------*/
/* Redéfinition de la fonction malloc() avec retour de type NDT_Status */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Default_Allocator( void **, NDT_Root *, size_t, void *);
/*----------------------------------------------------------------------------*/
/* Redéfinition de la fonction free() avec retour de type NDT_Status */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Default_Deallocator( void *, NDT_Root *, void *);
/*----------------------------------------------------------------------------*/
/* Création d'un noeud */
/*----------------------------------------------------------------------------*/
/* (I) Root : adresse de la racine pour laquelle on crée un noeud */
/* (O) New_Node : adresse du pointeur sur le nouveau noeud */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Node_Alloc( NDT_Root * Root, NDT_Node ** New_Node);
/*----------------------------------------------------------------------------*/
/* Destruction d'un noeud */
/*----------------------------------------------------------------------------*/
/* (I) Root : adresse de la racine dans laquelle on détruit un noeud */
/* (I) Node : pointeur sur le noeud à détruire */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Node_Free( NDT_Root *, NDT_Node *);
/*----------------------------------------------------------------------------*/
/* 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) Deallocator: 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_Index_Clear( NDT_Root *, NDT_Index_Id);
/*----------------------------------------------------------------------------*/
/* Destruction d'une racine */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine à détruire */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Node_Root_Free( NDT_Root *);
/*----------------------------------------------------------------------------*/
/* Ajout d'un noeud à une liste chaînée */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la liste */
/* (I) New_Node : pointeur sur le noeud à ajouter */
/*----------------------------------------------------------------------------*/
NDT_Status ND_List_Node_Add( NDT_Root *, NDT_Index_Id, NDT_Node *);
/*----------------------------------------------------------------------------*/
/* Ajout d'une nouvelle valeur à une liste */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la liste */
/* (I) Value : pointeur sur la valeur à ajouter */
/*----------------------------------------------------------------------------*/
NDT_Status ND_List_Value_Add( NDT_Root *, NDT_Index_Id, void *);
/*----------------------------------------------------------------------------*/
/* Ajout d'un noeud à un arbre binaire */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de l'arbre */
/* (I) Value : pointeur sur la valeur à ajouter */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Tree_Value_Add( NDT_Root *, NDT_Index_Id, void *);
/*----------------------------------------------------------------------------*/
/* Supprime le noeud d'une liste */
/*----------------------------------------------------------------------------*/
/* (I) Node : pointeur sur le noeud à supprimer */
/*----------------------------------------------------------------------------*/
NDT_Status ND_List_Node_Remove( NDT_Node *);
/*----------------------------------------------------------------------------*/
/* Conversion d'une structure en liste chaînée */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine du la structure à convertir */
/*----------------------------------------------------------------------------*/
NDT_Status ND_List_Make( NDT_Root *, NDT_Index_Id);
/*----------------------------------------------------------------------------*/
/* 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 *);
/*----------------------------------------------------------------------------*/
/* 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 *);
/*----------------------------------------------------------------------------*/
/* Conversion d'une structure en arbre binaire */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine du la structure à convertir */
/* (I) Type : type du futur arbre */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Tree_Make( NDT_Root *, NDT_Index_Id);
/*----------------------------------------------------------------------------*/
/* Equilibrage d'un arbre */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de l'arbre */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Tree_Equalize( NDT_Root *, NDT_Index_Id);
/*----------------------------------------------------------------------------*/
/* Retourne la profondeur de la plus grande branche à partir d'un noeud */
/*----------------------------------------------------------------------------*/
/* (I) Node : pointeur sur le noeud */
/*----------------------------------------------------------------------------*/
long ND_Tree_MaxDepth_Get( NDT_Node *);
/*----------------------------------------------------------------------------*/
/* Retourne la profondeur de la plus petite branche à partir d'un noeud */
/*----------------------------------------------------------------------------*/
/* (I) Node : pointeur sur le noeud */
/*----------------------------------------------------------------------------*/
long ND_Tree_MinDepth_Get( NDT_Node *);
/*----------------------------------------------------------------------------*/
/* Ajout d'un noeud à un arbre binaire */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de l'arbre */
/* (I) Node : pointeur sur le noeud à ajouter */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Tree_Node_Add( NDT_Root *, NDT_Index_Id, NDT_Node *);
/*----------------------------------------------------------------------------*/
/* Ajoute tous les noeud d'une liste à un arbre */
/*----------------------------------------------------------------------------*/
/* (I) Tree_Root : pointeur sur la racine de l'arbre */
/* (I) List_Root : pointeur sur la racine de la liste */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Tree_List_Add( NDT_Root *, NDT_Index_Id, NDT_Root *, NDT_Index_Id);
/*----------------------------------------------------------------------------*/
/* Fonction de comparaison de noeuds (pour le quick sort) */
/*----------------------------------------------------------------------------*/
int ND_Node_Compare( void **, void **);
/*----------------------------------------------------------------------------*/
/* Ordonne une liste chaînée selon l'algorithme du tri à bulle */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la liste à trier */
/*----------------------------------------------------------------------------*/
NDT_Status ND_List_Sort( NDT_Root *, NDT_Index_Id);
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* PRIVATE FUNCTIONS */
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* Init handler: */
/* - Return extra root size */
/* - Update handler tab */
/*----------------------------------------------------------------------------*/
/* (O) Root_Extra_Size_Ptr: Pointer on the extra root size */
/* (I) User_Ptr: User pointer */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Handler_Init_Default( NDT_Root **root_tmp_ptr_ptr, NDT_DataStruct_Name Name, NDT_Open_Flag Open_Mode, NDT_Index_Nb Index_Nb, NDT_Index_Type *Type_Ptr, NDT_Handler *Handler_Tab, short Own_Value, void *User_Ptr);
/*----------------------------------------------------------------------------*/
/* Default alloc handler: */
/* malloc() function wrapper with NDT_Status return status */
/*----------------------------------------------------------------------------*/
/* (O) Memory_Ptr_Ptr: Memory pointer address */
/* (I) Root_Ptr: Data structure pointer */
/* (I) Size: Allocation size */
/* (I) User_Ptr: User pointer */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Handler_Alloc_Default( void **Memory_Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size, void *User_Ptr);
/*----------------------------------------------------------------------------*/
/* Default free handler: */
/* free() function wrapper with NDT_Status return status */
/*----------------------------------------------------------------------------*/
/* (I) Memory_Ptr: Memory pointer */
/* (I) Root_Ptr: Data structure pointer */
/* (I) User_Ptr: User pointer */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Handler_Free_Default( void *Memory_Ptr, NDT_Root *Root_Ptr, void *User_Ptr);
/*----------------------------------------------------------------------------*/
/* Default open handler */
/*----------------------------------------------------------------------------*/
/* (I) Root_Ptr: Data structure pointer */
/* (I) Open_Mode: Open mode */
/* (I) Handler_Open_Name: Free handler function name */
/* (I) Handler_Open_Ptr: Free handler function pointer */
/* (I) User_Ptr: User pointer */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Handler_Open_Default( NDT_Root *Root_Ptr, NDT_Open_Flag Open_Mode, void *User_Ptr);
/*----------------------------------------------------------------------------*/
/* Default close handler */
/*----------------------------------------------------------------------------*/
/* (I) Root_Ptr: Data structure pointer */
/* (I) Close_Mode: Close mode */
/* (I) Handler_Close_Name: Free handler function name */
/* (I) Handler_Close_Ptr: Free handler function pointer */
/* (I) User_Ptr: User pointer */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Handler_Close_Default( NDT_Root *Root_Ptr, NDT_Close_Flag Close_Mode, void *User_Ptr);
/*----------------------------------------------------------------------------*/
/* Default info handler */
/*----------------------------------------------------------------------------*/
/* (I) Root_Ptr: Data structure pointer */
/* (I) Recursive_Offset: Print line offset */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Handler_Info_Default( NDT_Root *Root_Ptr, NDT_Recursive_Offset Recursive_Offset);
/*----------------------------------------------------------------------------*/
/* Default lock handler */
/*----------------------------------------------------------------------------*/
/* (I) Root_Ptr: Data structure pointer */
/* (I) Open_Mode: Lock mode */
/* (O) Locked_Ptr: Locked flag */
/* (I) Handler_Lock_Name: Free handler function name */
/* (I) Handler_Lock_Ptr: Free handler function pointer */
/* (I) User_Ptr: User pointer */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Handler_Lock_Default( NDT_Root *Root_Ptr, NDT_Lock_Flag Lock_Mode, bool *Locked_Ptr, void *User_Ptr);
/*----------------------------------------------------------------------------*/
/* Defalt unlock handler */
/*----------------------------------------------------------------------------*/
/* (I) Root_Ptr: Data structure pointer */
/* (I) Handler_Unlock_Name: Free handler function name */
/* (I) Handler_Unlock_Ptr: Free handler function pointer */
/* (I) User_Ptr: User pointer */
/*----------------------------------------------------------------------------*/
NDT_Status ND_Handler_Unlock_Default( NDT_Root *Root_Ptr, void *User_Ptr);
/*----------------------------------------------------------------------------*/
void ND_List_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *);
void ND_List_Link_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *);
void ND_Value_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *);
void ND_Tree_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *);
void ND_Tree_Link_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *);
NDT_Status ND_List_Recursive_Make( NDT_Node *, NDT_Root *, NDT_Index_Id);
NDT_Node *ND_Tree_Recursive_Make( long, long, NDT_Node *);
void ND_Tree_Node_Recursive_Add( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Node **, long , NDT_Node *);
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_Parent_Next_Recursive_Get( NDT_Node *);
NDT_Node *ND_Tree_Parent_Previous_Recursive_Get( NDT_Node *);
void ND_Tree_Recursive_Print( NDT_Node *, long, FILE *);
void ND_Tree_Link_Recursive_Check( NDT_Node *, int *, int *, FILE *);
NDT_Status ND_Symbol_Find( void **, const char *);
void ND_Signal_Trap( int);
NDT_Status ND_Address_Check( void *);
/*----------------------------------------------------------------------------*/
/* Post prototype global variable definitions */
/*----------------------------------------------------------------------------*/
NDT_Handler NDG_Handler_Tab_Default[ NDD_HANDLER_NB] =
{
{ "", /* Default Manager function name */
NULL}, /* Default Manager function pointer */
{ "ND_Handler_Init_Default", /* Default Init function name */
( NDT_Handler_Function *)ND_Handler_Init_Default}, /* Default Init function pointer */
{ "ND_Handler_Alloc_Default", /* Default Alloc function name */
( NDT_Handler_Function *)ND_Handler_Alloc_Default}, /* Default Alloc function pointer */
{ "ND_Handler_Free_Default", /* Default Free function name */
( NDT_Handler_Function *)ND_Handler_Free_Default}, /* Default Free function pointer */
{ "NDT_Handler_Open_Default", /* Default Open function name */
( NDT_Handler_Function *)ND_Handler_Open_Default}, /* Default Open function pointer */
{ "NDT_Handler_Close_Default", /* Default Close function name */
( NDT_Handler_Function *)ND_Handler_Close_Default}, /* Default Close function pointer */
{ "NDT_Handler_Info_Default", /* Default Info function name */
( NDT_Handler_Function *)ND_Handler_Info_Default}, /* Default Info function pointer */
{ "NDT_Handler_Lock_Default", /* Default Lock function name */
( NDT_Handler_Function *)ND_Handler_Lock_Default}, /* Default Lock function pointer */
{ "NDT_Handler_Unlock_Default", /* Default Unlock function name */
( NDT_Handler_Function *)ND_Handler_Unlock_Default} /* Default Unlock function pointer */
};