/*----------------------------------------------------------------------------*/
/* 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                                 */
/*    <https://www.gnu.org/licenses/>.                                        */
/*----------------------------------------------------------------------------*/



/*----------------------------------------------------------------------------*/
/* Includes                                                                   */
/*----------------------------------------------------------------------------*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <setjmp.h>
#include <dlfcn.h>



/* Utilisation des API de la LIBNODE sans vérification des arguments */

#define ND_MODE 1

#include <node.h>







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





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

/*----------------------------------------------------------------------------*/
/* 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) Deallocater : pointeur vers la fonction de désallocation               */
/* (I) Data         : pointeur de données utiles à l'allocateur               */
/*----------------------------------------------------------------------------*/
NDT_Status  ND_Node_Root_Alloc( NDT_Root  **, NDT_Index_Nb, NDT_Index_Type[], char  *, NDT_Manager  *, char  *, NDT_Allocator  *, char  *, NDT_Deallocator  *, short, void  *);

/*----------------------------------------------------------------------------*/
/* 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                             */
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

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