libnode/lib/libnode.h

/*---------------------------------------------------------------------------------*/
/* $RCSfile: libnode.h,v $														   */
/*---------------------------------------------------------------------------------*/
/* $Revision: 2.4 $															   */
/* $Name:  $															   */
/* $Date: 2002/07/29 14:53:51 $													   */
/* $Author: agibert $															   */
/*---------------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------------*/
/* 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 Licence as published by  */
/*    the Free Software Foundation; either version 2.1 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 Foobar; if not, write to the Free Software                        */
/*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    */
/*---------------------------------------------------------------------------------*/





#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
//#include <dlfcn.h>
#include <node.h>







#ifdef __linux

#   define NDD_PRINTF_PTR_PREFIX  ""

#else

#   define NDD_PRINTF_PTR_PREFIX  "0x"

#endif





#define NDD_HUGE_LONG (long)0xFFFFFFL

/* Sortie standard des messages d'erreur */

FILE * ND_stderr;

/* Table des symboles locale */

struct Symbol {
    void *          Ptr;
    char *          Name;
    struct Symbol * Next;
} * Symbol_Table = NULL;

NDT_Root * Tmp_Root;

//extern char * strdup (const char *);
//extern int sigrelse (int sig);

int Sig_Trapped;

/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
/*       Fonctions et proc<6F>dures priv<69>es de la librairie  (moyen niveau)        */
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------*/
/* Manager par d<>faut                                                           */
/*------------------------------------------------------------------------------*/
/* (I) va_list Arguments : Liste d'arguments contextuels                        */
/*------------------------------------------------------------------------------*/
NDT_Status  Default_Manager( NDT_Root  *, NDT_Index_Id, NDT_Command, va_list);

/*------------------------------------------------------------------------------*/
/* Red<65>finition de la fonction malloc() avec retour de type NDT_Status          */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Default_Allocator( size_t Size, void  **ptr, void  *User);

/*------------------------------------------------------------------------------*/
/* Red<65>finition de la fonction free() avec retour de type NDT_Status            */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Default_Desallocator( void  *, void  *);

/*------------------------------------------------------------------------------*/
/* Cr<43>ation d'un noeud                                                          */
/*------------------------------------------------------------------------------*/
/* (I) Root     : adresse de la racine pour laquelle on cr<63>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 <20> d<>truire                                  */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Node_Free (NDT_Root * Root, NDT_Node * Node);

/*------------------------------------------------------------------------------*/
/* 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_Index_Clear( NDT_Root  *, NDT_Index_Id);

/*------------------------------------------------------------------------------*/
/* Cr<43>ation de la racine d'une structure de donn<6E>es quelconque                  */
/*------------------------------------------------------------------------------*/
/* (O) New_Root     : adresse du pointeur sur la nouvelle racine                */
/* (I) Type         : type de la structure de donn<6E>es                           */
/* (I) Allocater    : pointeur vers la fonction d'allocation                    */
/* (I) Desallocater : pointeur vers la fonction de d<>sallocation                */
/* (I) Data         : pointeur de donn<6E>es utiles <20> l'allocateur                 */
/*------------------------------------------------------------------------------*/
NDT_Status  ND_Node_Root_Alloc( NDT_Root  **, NDT_Index_Nb, NDT_Index_Type[], char  *, NDT_Manager  *, char  *, NDT_Allocator  *, char  *, NDT_Desallocator  *, short, void  *);

/*------------------------------------------------------------------------------*/
/* Destruction d'une racine                                                     */
/*------------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine <20> d<>truire                                 */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Node_Root_Free (NDT_Root * Root);

/*------------------------------------------------------------------------------*/
/* Ajout d'un noeud <20> une liste cha<68>n<EFBFBD>e                                         */
/*------------------------------------------------------------------------------*/
/* (I) Root     : pointeur sur la racine de la liste                            */
/* (I) New_Node : pointeur sur le noeud <20> ajouter                               */
/*------------------------------------------------------------------------------*/
NDT_Status ND_List_Node_Add (NDT_Root  *, NDT_Index_Id, NDT_Node  *);

/*------------------------------------------------------------------------------*/
/* Ajout d'une nouvelle valeur <20> une liste                                      */
/*------------------------------------------------------------------------------*/
/* (I) Root     : pointeur sur la racine de la liste                            */
/* (I) Value    : pointeur sur la valeur <20> ajouter                              */
/*------------------------------------------------------------------------------*/
NDT_Status ND_List_Value_Add (NDT_Root  *, NDT_Index_Id, void  *);

/*------------------------------------------------------------------------------*/
/* Ajout d'un noeud <20> un arbre binaire                                          */
/*------------------------------------------------------------------------------*/
/* (I) Root     : pointeur sur la racine de l'arbre                             */
/* (I) Value    : pointeur sur la valeur <20> 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 <20> supprimer                                */
/*------------------------------------------------------------------------------*/
NDT_Status ND_List_Node_Remove (NDT_Node  *);

/*------------------------------------------------------------------------------*/
/* Conversion d'une structure en liste cha<68>n<EFBFBD>e                                  */
/*------------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine du la structure <20> 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 <20> 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 <20> partir d'un noeud         */
/*------------------------------------------------------------------------------*/
/* (I) Node : pointeur sur le noeud                                             */
/*------------------------------------------------------------------------------*/
long ND_Tree_MaxDepth_Get (NDT_Node  *Node);

/*------------------------------------------------------------------------------*/
/* Retourne la profondeur de la plus petite branche <20> partir d'un noeud         */
/*------------------------------------------------------------------------------*/
/* (I) Node : pointeur sur le noeud                                             */
/*------------------------------------------------------------------------------*/
long ND_Tree_MinDepth_Get (NDT_Node  *Node);

/*------------------------------------------------------------------------------*/
/* Ajout d'un noeud <20> un arbre binaire                                          */
/*------------------------------------------------------------------------------*/
/* (I) Root    : pointeur sur la racine de l'arbre                              */
/* (I) Node : pointeur sur le noeud <20> ajouter                                   */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Tree_Node_Add (NDT_Root  *, NDT_Index_Id, NDT_Node  *);

/*------------------------------------------------------------------------------*/
/* Ajoute tous les noeud d'une liste <20> 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 ** Node1, void ** Node2);

/*------------------------------------------------------------------------------*/
/* Ordonne une liste cha<68>n<EFBFBD>e selon l'algorithme du tri <20> bulle                  */
/*------------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la liste <20> trier                        */
/*------------------------------------------------------------------------------*/
NDT_Status ND_List_Sort (NDT_Root  *, NDT_Index_Id);

/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
/*       Fonctions et proc<6F>dures priv<69>es de la librairie  (bas niveau)          */
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/

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 * Node);

NDT_Node * ND_Tree_Node_Last_Recursive_Get (NDT_Node * Node);

NDT_Node * ND_Tree_Node_Recursive_Find (NDT_Node * Node, void * Value, va_list);

NDT_Node * ND_Tree_Parent_Next_Recursive_Get (NDT_Node * Node);

NDT_Node * ND_Tree_Parent_Previous_Recursive_Get (NDT_Node * Node);

void ND_Tree_Recursive_Print (NDT_Node * Node, long Depth, FILE *);

void ND_Tree_Link_Recursive_Check (NDT_Node * Node, int *, int *, FILE *);

void * ND_Symbol_Find (const char *);

void ND_Error_Print (void);

void ND_Signal_Trap (int);

NDT_Status ND_Address_Check (void * Address);