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

#define HUGE_LONG 0xFFFFFFL

#ifndef min
#define min(A,B)  ((A > B) ? B : A)
#endif

#ifndef max
#define max(A,B)  ((A < B) ? B : A)
#endif

/* 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édures privées de la librairie  (moyen niveau)        */
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------*/
/* Manager par défaut                                                           */
/*------------------------------------------------------------------------------*/
/* (I) va_list Arguments : Liste d'arguments contextuels                        */
/*------------------------------------------------------------------------------*/
NDT_Status Default_Manager (va_list Arguments);

/*------------------------------------------------------------------------------*/
/* Redéfinition de la fonction malloc() avec retour de type NDT_Status          */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Malloc (size_t Size, void ** ptr, void * User);

/*------------------------------------------------------------------------------*/
/* Redéfinition de la fonction free() avec retour de type NDT_Status            */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Free (void * ptr);

/*------------------------------------------------------------------------------*/
/* 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 * Root, NDT_Node * Node);

/*------------------------------------------------------------------------------*/
/* Création de la racine d'une structure de données quelconque                  */
/*------------------------------------------------------------------------------*/
/* (O) New_Root     : adresse du pointeur sur la nouvelle racine                */
/* (I) Type         : type de la structure de données                           */
/* (I) Allocater    : pointeur vers la fonction d'allocation                    */
/* (I) Desallocater : pointeur vers la fonction de désallocation                */
/* (I) Data         : pointeur de données utiles à l'allocateur                 */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Root_Alloc (NDT_Root ** Root, NDT_DataStruct_Type Type, \
                          const char * Allocator, const char * Desallocator, \
                          void * Data);

/*------------------------------------------------------------------------------*/
/* Destruction d'une racine                                                     */
/*------------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine à détruire                                 */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Root_Free (NDT_Root * 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 * Root, NDT_Node * New_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 * Root,  void * Value);

/*------------------------------------------------------------------------------*/
/* 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 * Root, void * Value);

/*------------------------------------------------------------------------------*/
/* Supprime le noeud d'une liste                                                */
/*------------------------------------------------------------------------------*/
/* (I) Node  : pointeur sur le noeud à supprimer                                */
/*------------------------------------------------------------------------------*/
NDT_Status ND_List_Node_Remove (NDT_Node * 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 * Root);

/*------------------------------------------------------------------------------*/
/* Recherche une valeur dans une liste et retourne le noeud correspondant       */
/*------------------------------------------------------------------------------*/
NDT_Node * ND_List_Node_Find (NDT_Root * Root, void * Value, void * Data);

/*------------------------------------------------------------------------------*/
/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud        */
/*------------------------------------------------------------------------------*/
NDT_Node * ND_Tree_Node_Find (NDT_Root * Root, void * Value, void * Data);

/*------------------------------------------------------------------------------*/
/* 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 * Root);

/*------------------------------------------------------------------------------*/
/* Equilibrage d'un arbre                                                       */
/*------------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de l'arbre                                 */
/*------------------------------------------------------------------------------*/
NDT_Status ND_Tree_Equalize (NDT_Root * Root);

/*------------------------------------------------------------------------------*/
/* 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 * 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 * 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 * Root, NDT_Node * 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 * Tree_Root,   NDT_Root * List_Root);

/*------------------------------------------------------------------------------*/
/* Fonction de comparaison de noeuds (pour le quick sort)                       */
/*------------------------------------------------------------------------------*/
int ND_Node_Compare (void ** Node1, void ** Node2);

/*------------------------------------------------------------------------------*/
/* 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 * Root);

/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/
/*       Fonctions et procédures privées de la librairie  (bas niveau)          */
/*------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------*/

void ND_List_Check (NDT_Root *, int *, int *, FILE *);

void ND_List_Link_Check (NDT_Root *, int *, int *, FILE *);

void ND_Value_Check (NDT_Root *, int *, int *, FILE *);

void ND_Tree_Check (NDT_Root *, int *, int *, FILE *);

void ND_Tree_Link_Check (NDT_Root *, int *, int *, FILE *);

NDT_Status ND_List_Recursive_Make (NDT_Node *, NDT_Root *);

NDT_Node * ND_Tree_Recursive_Make (long, long, NDT_Node *);

void ND_Tree_Node_Recursive_Add (NDT_Root *, 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, void * Data);

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