diff --git a/include/datastr.h b/include/datastr.h index 453a344..362bcfe 100644 --- a/include/datastr.h +++ b/include/datastr.h @@ -1,8 +1,36 @@ +/*----------------------------------------------------------------------------*/ +/* datastr.h */ +/*----------------------------------------------------------------------------*/ + +/*----------------------------------------------------------------------------*/ +/* This file is part of LibDataStr. */ +/* */ +/* LibDataStr 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. */ +/* */ +/* LibDataStr 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 LibDataStr. If not, see */ +/* . */ +/*----------------------------------------------------------------------------*/ + + + +/*----------------------------------------------------------------------------*/ +/* Includes */ +/*----------------------------------------------------------------------------*/ + #ifndef _LIBDATASTR #define _LIBDATASTR #ifdef __cplusplus -extern "C" { +//extern "C" { #endif #include @@ -25,49 +53,57 @@ typedef long DST_Status; #define DS_ERROR(s) ((s) < 0) /* Tous les codes retour négatifs correspondent à des erreurs */ + + /* Indicateurs */ typedef int DST_Flags; #define DSD_UNDEF 0 + + /* Flags d'ouverture d'une data structure */ #define DSD_OPEN SMD_OPEN /* autorise l'ouverture d'une structure existante */ #define DSD_CREATE SMD_CREATE /* autorise la création de la structure */ #define DSD_NEW ~(DSD_OPEN|DSD_CREATE) /* crée une autre structure dans un heap existant */ + + /* Flags de debug sur l'ouverture de la librairie */ #define DSD_DEBUG_NONE 0 /* pour n'afficher aucun message généré par les diverses librairies */ #define DSD_DEBUG 1 /* pour afficher les messages générés par la librairie */ #define DSD_DEBUG_ALL 2 /* pour afficher les messages générés par toutes les librairies sous-jacentes */ -/*------------------------------------------------------------------------------*/ -/* Utilisations possibles des flags d'ouverture */ -/*------------------------------------------------------------------------------*/ -/* */ -/* DSD_OPEN */ -/* -> ouvrir une structure existante */ -/* -> ne pas la créer si elle n'existe pas */ -/* */ -/* DSD_OPEN | DSD_CREATE */ -/* -> ouvrir une structure si elle existe */ -/* -> la créer si elle n'existe pas */ -/* */ -/* DSD_CREATE */ -/* -> créer une structure */ -/* -> ne pas l'ouvrir si elle existe déjà */ -/* */ -/* DSD_CREATE | DSD_NEW */ -/* -> créer la structure si elle n'existe pas */ -/* -> créer une autre structure dans le même heap si elle existe déjà */ -/* */ -/* DSD_NEW */ -/* -> créer une autre structure dans le même heap si elle existe déjà */ -/* -> ne pas la créer si elle n'existe pas */ -/* */ -/*------------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Utilisations possibles des flags d'ouverture */ +/*----------------------------------------------------------------------------*/ +/* */ +/* DSD_OPEN */ +/* -> ouvrir une structure existante */ +/* -> ne pas la créer si elle n'existe pas */ +/* */ +/* DSD_OPEN | DSD_CREATE */ +/* -> ouvrir une structure si elle existe */ +/* -> la créer si elle n'existe pas */ +/* */ +/* DSD_CREATE */ +/* -> créer une structure */ +/* -> ne pas l'ouvrir si elle existe déjà */ +/* */ +/* DSD_CREATE | DSD_NEW */ +/* -> créer la structure si elle n'existe pas */ +/* -> créer une autre structure dans le même heap si elle existe déjà */ +/* */ +/* DSD_NEW */ +/* -> créer une autre structure dans le même heap si elle existe déjà */ +/* -> ne pas la créer si elle n'existe pas */ +/* */ +/*----------------------------------------------------------------------------*/ /* Flags de verrouillage d'une data structure */ @@ -224,316 +260,387 @@ char DS_Error_Msg [512]; #endif -/*------------------------------------------------------------------------------*/ -/* Ouverture d'une instance de la librairie */ -/*------------------------------------------------------------------------------*/ -/* (I) Instance : numéro de l'instance de la librairie */ -/* (I) Context : nom du contexte */ -/* (I) Debug_Mode : mode d'affichage des messages d'erreur */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Library_Open_I ( int Instance, const char * Context, \ - DST_Flags Debug_Mode ); -DST_Status DS_Library_Open_L ( int Instance, const char * Context, \ - DST_Flags Debug_Mode ); -DST_Status DS_Library_Open_CL ( int Instance, const char * Context, \ - DST_Flags Debug_Mode ); -/*------------------------------------------------------------------------------*/ -/* Fermeture de l'instance de la librairie */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Library_Close_I ( void ); -DST_Status DS_Library_Close_L ( void ); -DST_Status DS_Library_Close_CL ( void ); -/*------------------------------------------------------------------------------*/ -/* Définition de la sortie standard des messages d'erreur de la librairie */ -/*------------------------------------------------------------------------------*/ -/* (I) Out : flux de sortie des messages d'erreur */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Library_Stderr_Set_I ( FILE * Out ); -DST_Status DS_Library_Stderr_Set_L ( FILE * Out ); -DST_Status DS_Library_Stderr_Set_CL ( FILE * Out ); +/*----------------------------------------------------------------------------*/ +/* DSD_API definition */ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* Création / ouverture d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) DS_Name : nom de la structure */ -/* (O) Root : adresse du pointeur sur la racine de la structure */ -/* (I) Type : type de la structure de données */ -/* (I) Manager_FileName : nom du fichier qui définit les fonctions manager */ -/* (I) Segment_Size : taille ds segments du heap sous-jacent */ -/* (I) Open_Mode : mode d'ouverture de la structure */ -/* (I) Own_Value : indique si la structure possède ses valeurs */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Open_I ( const char * DS_Name, NDT_Root ** Root,\ - NDT_DataStruct_Type Type, const char * Manager_FileName, \ - size_t Segment_Size, DST_Flags Open_Mode, int Own_Value ); -DST_Status DS_DataStruct_Open_L ( const char * DS_Name, NDT_Root ** Root,\ - NDT_DataStruct_Type Type, const char * Manager_FileName, \ - size_t Segment_Size, DST_Flags Open_Mode, int Own_Value ); -DST_Status DS_DataStruct_Open_CL ( const char * DS_Name, NDT_Root ** Root,\ - NDT_DataStruct_Type Type, const char * Manager_FileName, \ - size_t Segment_Size, DST_Flags Open_Mode, int Own_Value ); +# ifdef _LIBDATASTR_C_ +# define DSD_API +# else +# define DSD_API extern +# endif -/*------------------------------------------------------------------------------*/ -/* Verrouillage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (I) Lock_Mode : type de verrou à poser sur la structure */ -/* (O) Locked : verrou effectif (TRUE ou FALSE) */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Lock_I ( NDT_Root * Root, DST_Flags Lock_Mode, \ - int * Locked ); -DST_Status DS_DataStruct_Lock_L ( NDT_Root * Root, DST_Flags Lock_Mode, \ - int * Locked ); -DST_Status DS_DataStruct_Lock_CL ( NDT_Root * Root, DST_Flags Lock_Mode, \ - int * Locked ); -/*------------------------------------------------------------------------------*/ -/* Déverrouillage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Unlock_I ( NDT_Root * Root ); -DST_Status DS_DataStruct_Unlock_L ( NDT_Root * Root ); -DST_Status DS_DataStruct_Unlock_CL ( NDT_Root * Root ); -/*------------------------------------------------------------------------------*/ -/* Fermeture d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données */ -/* (I) Close_Mode : mode de fermeture de la structure (destruction ou non) */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ); -DST_Status DS_DataStruct_Close_L ( NDT_Root * Root, DST_Flags Close_Mode ); -DST_Status DS_DataStruct_Close_CL ( NDT_Root * Root, DST_Flags Close_Mode ); +/*----------------------------------------------------------------------------*/ +/* Ouverture d'une instance de la librairie */ +/*----------------------------------------------------------------------------*/ +/* (I) Instance : numéro de l'instance de la librairie */ +/* (I) Context : nom du contexte */ +/* (I) Debug_Mode : mode d'affichage des messages d'erreur */ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* Affiche les informations d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root: pointeur sur la racine de la structure de données */ -/* (I) Out : flux de sortie de l'affichage */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Info_Print_I ( NDT_Root * Root, FILE * Out ); -DST_Status DS_DataStruct_Info_Print_L ( NDT_Root * Root, FILE * Out ); -DST_Status DS_DataStruct_Info_Print_CL ( NDT_Root * Root, FILE * Out ); +DSD_API DST_Status DS_Library_Open_I( int Instance, const char *Context, DST_Flags Debug_Mode); +DSD_API DST_Status DS_Library_Open_L( int Instance, const char *Context, DST_Flags Debug_Mode); +DSD_API DST_Status DS_Library_Open_CL( int Instance, const char *Context, DST_Flags Debug_Mode); -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Reorg_I ( NDT_Root * Root ); -DST_Status DS_DataStruct_Reorg_L ( NDT_Root * Root ); -DST_Status DS_DataStruct_Reorg_CL ( 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Traverse_I ( NDT_Root * Root, NDT_Command Command, \ - void * Data ); -DST_Status DS_DataStruct_Traverse_L ( NDT_Root * Root, NDT_Command Command, \ - void * Data ); -DST_Status DS_DataStruct_Traverse_CL ( 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Convert_I ( NDT_Root * Root, \ - NDT_DataStruct_Type Target_Type ); -DST_Status DS_DataStruct_Convert_L ( NDT_Root * Root, \ - NDT_DataStruct_Type Target_Type ); -DST_Status DS_DataStruct_Convert_CL ( NDT_Root * Root, \ - NDT_DataStruct_Type Target_Type ); +/*----------------------------------------------------------------------------*/ +/* Fermeture de l'instance de la librairie */ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Print_I ( NDT_Root * Root, FILE * Out ); -DST_Status DS_DataStruct_Print_L ( NDT_Root * Root, FILE * Out ); -DST_Status DS_DataStruct_Print_CL ( NDT_Root * Root, FILE * Out ); +DSD_API DST_Status DS_Library_Close_I( void); +DSD_API DST_Status DS_Library_Close_L( void); +DSD_API DST_Status DS_Library_Close_CL( void); -/*------------------------------------------------------------------------------*/ -/* Fonction de vérification / réparation d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (O) Nb_Detected : pointeur sur le nombre d'erreurs détectées */ -/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */ -/* (I) Out : flux de sortie du rapport */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, \ - int * Nb_Corrected, FILE * Out ); -DST_Status DS_DataStruct_Check_L ( NDT_Root * Root, int * Nb_Detected, \ - int * Nb_Corrected, FILE * Out ); -DST_Status DS_DataStruct_Check_CL ( NDT_Root * Root, int * Nb_Detected, \ - int * Nb_Corrected, FILE * Out ); -/*------------------------------------------------------------------------------*/ -/* Affichage de la structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (I) Out : flux de sortie */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Dump_I ( NDT_Root * Root, FILE * Out ); -DST_Status DS_DataStruct_Dump_L ( NDT_Root * Root, FILE * Out ); -DST_Status DS_DataStruct_Dump_CL ( NDT_Root * Root, FILE * Out ); -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Node_First_Get_I ( NDT_Root * Root, NDT_Node ** Node ); -DST_Status DS_Node_First_Get_L ( NDT_Root * Root, NDT_Node ** Node ); -DST_Status DS_Node_First_Get_CL ( NDT_Root * Root, NDT_Node ** Node ); +/*----------------------------------------------------------------------------*/ +/* Définition de la sortie standard des messages d'erreur de la librairie */ +/*----------------------------------------------------------------------------*/ +/* (I) Out : flux de sortie des messages d'erreur */ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Node_Last_Get_I ( NDT_Root * Root, NDT_Node ** Node ); -DST_Status DS_Node_Last_Get_L ( NDT_Root * Root, NDT_Node ** Node ); -DST_Status DS_Node_Last_Get_CL ( NDT_Root * Root, NDT_Node ** Node ); +DSD_API DST_Status DS_Library_Stderr_Set_I( FILE *Out); +DSD_API DST_Status DS_Library_Stderr_Set_L( FILE *Out); +DSD_API DST_Status DS_Library_Stderr_Set_CL( FILE *Out); -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Node_Next_Get_I ( NDT_Node * Node, NDT_Node ** Next_Node ); -DST_Status DS_Node_Next_Get_L ( NDT_Node * Node, NDT_Node ** Next_Node ); -DST_Status DS_Node_Next_Get_CL ( 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Node_Previous_Get_I ( NDT_Node * Node, NDT_Node ** Prev_Node ); -DST_Status DS_Node_Previous_Get_L ( NDT_Node * Node, NDT_Node ** Prev_Node ); -DST_Status DS_Node_Previous_Get_CL ( 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Node_Add_I ( NDT_Root * Root, NDT_Node * Node ); -DST_Status DS_Node_Add_L ( NDT_Root * Root, NDT_Node * Node ); -DST_Status DS_Node_Add_CL ( NDT_Root * Root, NDT_Node * Node ); +/*----------------------------------------------------------------------------*/ +/* Création / ouverture d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (O) Root : adresse du pointeur sur la racine de la structure */ +/* (I) DS_Name : nom de la structure */ +/* (I) Type : type de la structure de données */ +/* (I) Manager_FileName : nom du fichier qui définit les fonctions manager */ +/* (I) Segment_Size : taille ds segments du heap sous-jacent */ +/* (I) Open_Mode : mode d'ouverture de la structure */ +/* (I) Own_Value : indique si la structure possède ses valeurs */ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* Suppression d'un noeud dans une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Node: pointeur sur le noeud à supprimer de la structure de données */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Node_Remove_I ( NDT_Node * Node ); -DST_Status DS_Node_Remove_L ( NDT_Node * Node ); -DST_Status DS_Node_Remove_CL ( NDT_Node * Node ); +DSD_API DST_Status DS_DataStruct_Open_I( NDT_Root **Root, const char *DS_Name, NDT_Index_Nb, NDT_Index_Type *, const char * Manager_FileName, size_t Segment_Size, DST_Flags Open_Mode, int Own_Value); -/*------------------------------------------------------------------------------*/ -/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de l'abre */ -/* (O) Node : adresse du pointeur sur le noeud à récuperer */ -/* (I) Value : pointeur sur la valeur à rechercher */ -/* (I) Data : pointeur de données */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Node_Find_I ( NDT_Root * Root, NDT_Node ** Node, \ - void * Value, void * Data ); -DST_Status DS_Node_Find_L ( NDT_Root * Root, NDT_Node ** Node, \ - void * Value, void * Data ); -DST_Status DS_Node_Find_CL ( NDT_Root * Root, NDT_Node ** Node, \ - void * Value, void * Data ); +/* +DSD_API DST_Status DS_DataStruct_Open_I( const char *DS_Name, NDT_Root **Root, NDT_DataStruct_Type Type, const char * Manager_FileName, size_t Segment_Size, DST_Flags Open_Mode, int Own_Value); +DSD_API DST_Status DS_DataStruct_Open_L( const char *DS_Name, NDT_Root **Root, NDT_DataStruct_Type Type, const char * Manager_FileName, size_t Segment_Size, DST_Flags Open_Mode, int Own_Value); +DSD_API DST_Status DS_DataStruct_Open_CL( const char *DS_Name, NDT_Root **Root, NDT_DataStruct_Type Type, const char * Manager_FileName, size_t Segment_Size, DST_Flags Open_Mode, int Own_Value); -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Value_Alloc_I ( NDT_Root * Root, void ** Value, ... ); -DST_Status DS_Value_Alloc_L ( NDT_Root * Root, void ** Value, ... ); -DST_Status DS_Value_Alloc_CL ( 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Value_Add_I ( NDT_Root * Root, void * Value ); -DST_Status DS_Value_Add_L ( NDT_Root * Root, void * Value ); -DST_Status DS_Value_Add_CL ( 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Value_Remove_I ( NDT_Root * Root, void * Reference_Value, \ - void ** Removed_Value); -DST_Status DS_Value_Remove_L ( NDT_Root * Root, void * Reference_Value, \ - void ** Removed_Value); -DST_Status DS_Value_Remove_CL ( NDT_Root * Root, void * Reference_Value, \ - void ** Removed_Value); +/*----------------------------------------------------------------------------*/ +/* Verrouillage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (I) Lock_Mode : type de verrou à poser sur la structure */ +/* (O) Locked : verrou effectif (TRUE ou FALSE) */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_DataStruct_Lock_I( NDT_Root * Root, DST_Flags Lock_Mode, int * Locked); +DSD_API DST_Status DS_DataStruct_Lock_L( NDT_Root * Root, DST_Flags Lock_Mode, int * Locked); +DSD_API DST_Status DS_DataStruct_Lock_CL( NDT_Root * Root, DST_Flags Lock_Mode, int * Locked); -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Value_Free_I ( NDT_Root * Root, void * Value ); -DST_Status DS_Value_Free_L ( NDT_Root * Root, void * Value ); -DST_Status DS_Value_Free_CL ( NDT_Root * Root, void * Value ); -/*------------------------------------------------------------------------------*/ -/* Allocation de mémoire pour une structure de données : */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données */ -/* (I) Size : taille mémoire à allouer */ -/* (O) Ptr : adresse du pointeur sur la zone de données allouée */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Alloc_I ( NDT_Root * Root, size_t Size, void ** Ptr ); -DST_Status DS_Alloc_L ( NDT_Root * Root, size_t Size, void ** Ptr ); -DST_Status DS_Alloc_CL ( NDT_Root * Root, size_t Size, void ** Ptr ); -/*------------------------------------------------------------------------------*/ -/* Désallocation d'une ressource pour une structure de données : */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données */ -/* (I) Ptr : pointeur sur la zone à désallouer */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_Free_I ( NDT_Root * Root, void * Ptr ); -DST_Status DS_Free_L ( NDT_Root * Root, void * Ptr ); -DST_Status DS_Free_CL ( NDT_Root * Root, void * Ptr ); +/*----------------------------------------------------------------------------*/ +/* Déverrouillage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_DataStruct_Unlock_I( NDT_Root * Root); +DSD_API DST_Status DS_DataStruct_Unlock_L( NDT_Root * Root); +DSD_API DST_Status DS_DataStruct_Unlock_CL( NDT_Root * Root); + + + +/*----------------------------------------------------------------------------*/ +/* Fermeture d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données */ +/* (I) Close_Mode : mode de fermeture de la structure (destruction ou non) */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_DataStruct_Close_I( NDT_Root * Root, DST_Flags Close_Mode); +DSD_API DST_Status DS_DataStruct_Close_L( NDT_Root * Root, DST_Flags Close_Mode); +DSD_API DST_Status DS_DataStruct_Close_CL( NDT_Root * Root, DST_Flags Close_Mode); + + + +/*----------------------------------------------------------------------------*/ +/* Affiche les informations d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root: pointeur sur la racine de la structure de données */ +/* (I) Out : flux de sortie de l'affichage */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_DataStruct_Info_Print_I( NDT_Root * Root, FILE * Out); +DSD_API DST_Status DS_DataStruct_Info_Print_L( NDT_Root * Root, FILE * Out); +DSD_API DST_Status DS_DataStruct_Info_Print_CL( NDT_Root * Root, FILE * Out); + + + +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_DataStruct_Reorg_I( NDT_Root * Root); +DSD_API DST_Status DS_DataStruct_Reorg_L( NDT_Root * Root); +DSD_API DST_Status DS_DataStruct_Reorg_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_DataStruct_Traverse_I( NDT_Root * Root, NDT_Command Command, void * Data); +DSD_API DST_Status DS_DataStruct_Traverse_L( NDT_Root * Root, NDT_Command Command, void * Data); +DSD_API DST_Status DS_DataStruct_Traverse_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_DataStruct_Convert_I( NDT_Root * Root, NDT_DataStruct_Type Target_Type); +DSD_API DST_Status DS_DataStruct_Convert_L( NDT_Root * Root, NDT_DataStruct_Type Target_Type); +DSD_API DST_Status DS_DataStruct_Convert_CL( NDT_Root * Root, NDT_DataStruct_Type Target_Type); + + + +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_DataStruct_Print_I( NDT_Root * Root, FILE * Out); +DSD_API DST_Status DS_DataStruct_Print_L( NDT_Root * Root, FILE * Out); +DSD_API DST_Status DS_DataStruct_Print_CL( NDT_Root * Root, FILE * Out); + + + +/*----------------------------------------------------------------------------*/ +/* Fonction de vérification / réparation d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (O) Nb_Detected : pointeur sur le nombre d'erreurs détectées */ +/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */ +/* (I) Out : flux de sortie du rapport */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_DataStruct_Check_I( NDT_Root * Root, int * Nb_Detected, int * Nb_Corrected, FILE * Out); +DSD_API DST_Status DS_DataStruct_Check_L( NDT_Root * Root, int * Nb_Detected, int * Nb_Corrected, FILE * Out); +DSD_API DST_Status DS_DataStruct_Check_CL( NDT_Root * Root, int * Nb_Detected, int * Nb_Corrected, FILE * Out); + + + +/*----------------------------------------------------------------------------*/ +/* Affichage de la structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (I) Out : flux de sortie */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_DataStruct_Dump_I( NDT_Root * Root, FILE * Out); +DSD_API DST_Status DS_DataStruct_Dump_L( NDT_Root * Root, FILE * Out); +DSD_API DST_Status DS_DataStruct_Dump_CL( NDT_Root * Root, FILE * Out); + + + +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Node_First_Get_I( NDT_Root * Root, NDT_Node ** Node); +DSD_API DST_Status DS_Node_First_Get_L( NDT_Root * Root, NDT_Node ** Node); +DSD_API DST_Status DS_Node_First_Get_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Node_Last_Get_I( NDT_Root * Root, NDT_Node ** Node); +DSD_API DST_Status DS_Node_Last_Get_L( NDT_Root * Root, NDT_Node ** Node); +DSD_API DST_Status DS_Node_Last_Get_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Node_Next_Get_I( NDT_Node * Node, NDT_Node ** Next_Node); +DSD_API DST_Status DS_Node_Next_Get_L( NDT_Node * Node, NDT_Node ** Next_Node); +DSD_API DST_Status DS_Node_Next_Get_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Node_Previous_Get_I( NDT_Node * Node, NDT_Node ** Prev_Node); +DSD_API DST_Status DS_Node_Previous_Get_L( NDT_Node * Node, NDT_Node ** Prev_Node); +DSD_API DST_Status DS_Node_Previous_Get_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Node_Add_I( NDT_Root * Root, NDT_Node * Node); +DSD_API DST_Status DS_Node_Add_L( NDT_Root * Root, NDT_Node * Node); +DSD_API DST_Status DS_Node_Add_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Node_Remove_I( NDT_Node * Node); +DSD_API DST_Status DS_Node_Remove_L( NDT_Node * Node); +DSD_API DST_Status DS_Node_Remove_CL( NDT_Node * Node); + + + +/*----------------------------------------------------------------------------*/ +/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de l'abre */ +/* (O) Node : adresse du pointeur sur le noeud à récuperer */ +/* (I) Value : pointeur sur la valeur à rechercher */ +/* (I) Data : pointeur de données */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Node_Find_I( NDT_Root * Root, NDT_Node ** Node, void * Value, void * Data); +DSD_API DST_Status DS_Node_Find_L( NDT_Root * Root, NDT_Node ** Node, void * Value, void * Data); +DSD_API DST_Status DS_Node_Find_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Value_Alloc_I( NDT_Root * Root, void ** Value, ...); +DSD_API DST_Status DS_Value_Alloc_L( NDT_Root * Root, void ** Value, ...); +DSD_API DST_Status DS_Value_Alloc_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Value_Add_I( NDT_Root * Root, void * Value); +DSD_API DST_Status DS_Value_Add_L( NDT_Root * Root, void * Value); +DSD_API DST_Status DS_Value_Add_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Value_Remove_I( NDT_Root * Root, void * Reference_Value, void ** Removed_Value); +DSD_API DST_Status DS_Value_Remove_L( NDT_Root * Root, void * Reference_Value, void ** Removed_Value); +DSD_API DST_Status DS_Value_Remove_CL( 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 */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Value_Free_I( NDT_Root * Root, void * Value); +DSD_API DST_Status DS_Value_Free_L( NDT_Root * Root, void * Value); +DSD_API DST_Status DS_Value_Free_CL( NDT_Root * Root, void * Value); + + + +/*----------------------------------------------------------------------------*/ +/* Allocation de mémoire pour une structure de données : */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données */ +/* (I) Size : taille mémoire à allouer */ +/* (O) Ptr : adresse du pointeur sur la zone de données allouée */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Alloc_I( NDT_Root * Root, size_t Size, void ** Ptr); +DSD_API DST_Status DS_Alloc_L( NDT_Root * Root, size_t Size, void ** Ptr); +DSD_API DST_Status DS_Alloc_CL( NDT_Root * Root, size_t Size, void ** Ptr); + + + +/*----------------------------------------------------------------------------*/ +/* Désallocation d'une ressource pour une structure de données : */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données */ +/* (I) Ptr : pointeur sur la zone à désallouer */ +/*----------------------------------------------------------------------------*/ +/* +DSD_API DST_Status DS_Free_I( NDT_Root * Root, void * Ptr); +DSD_API DST_Status DS_Free_L( NDT_Root * Root, void * Ptr); +DSD_API DST_Status DS_Free_CL( NDT_Root * Root, void * Ptr); +*/ + #ifdef __cplusplus -} +//} #endif #endif diff --git a/lib/Makefile b/lib/Makefile index 767e834..67579e1 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -1,6 +1,6 @@ -SRC := libdatatstr.c -TARGETS := libdatatstr.a libdatatstr.so -FILE_LIB := libdatatstr.a libdatatstr.so +SRC := libdatastr.c +TARGETS := libdatastr.a libdatastr.so +FILE_LIB := libdatastr.a libdatastr.so @@ -9,8 +9,8 @@ include ../Makefile.rule -DEP += libdatatstr.h ../include/datatstr.h ../../liblog/include/log.h Makefile -INCLUDE += -I . -I ../include -I ../../liblog/include +DEP += libdatastr.h ../include/datastr.h ../../liblog/include/log.h ../../libnode/include/node.h ../../libshmem/include/shmem.h Makefile +INCLUDE += -I . -I ../include -I ../../liblog/include -I ../../libnode/include -I ../../libshmem/include ifdef _LIBVER_SUPPORT DEP += ../../libver/ver.h @@ -19,4 +19,4 @@ endif -libdatatstr.o : libdatatstr.c $(DEP) +libdatastr.o : libdatastr.c $(DEP) diff --git a/lib/libdatastr.c b/lib/libdatastr.c index 3f5d02a..4f6a5f2 100644 --- a/lib/libdatastr.c +++ b/lib/libdatastr.c @@ -1,3 +1,35 @@ +/*----------------------------------------------------------------------------*/ +/* libdatastr.c */ +/*----------------------------------------------------------------------------*/ + +/*----------------------------------------------------------------------------*/ +/* This file is part of LibDataStr. */ +/* */ +/* LibDataStr 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. */ +/* */ +/* LibDataStr 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 LibDataStr. If not, see */ +/* . */ +/*----------------------------------------------------------------------------*/ + + + +/*----------------------------------------------------------------------------*/ +/* Includes */ +/*----------------------------------------------------------------------------*/ + +#define _LIBDATASTR_C_ + + + /* Utilisation des API sans vérification des arguments */ #define ND_MODE 1 @@ -5,25 +37,26 @@ #include -VER_INFO_EXPORT (libdatastr,"$Revision: 1.1 $", "$Name: $",__FILE__,"$Author: smas $") +//VER_INFO_EXPORT (libdatastr,"$Revision: 1.1 $", "$Name: $",__FILE__,"$Author: smas $") -/*------------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* FONCTIONS PUBLIQUES */ -/*------------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* FONCTIONS PUBLIQUES */ +/*----------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* FONCTIONS OPTIMISATION MAXIMALE (DS_MODE = 2) */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* FONCTIONS OPTIMISATION MAXIMALE (DS_MODE = 2) */ +/*----------------------------------------------------------------------------*/ + +/*----------------------------------------------------------------------------*/ +/* Ouverture d'une instance de la librairie */ +/*----------------------------------------------------------------------------*/ +/* (I) Instance : numéro de l'instance de la librairie */ +/* (I) Context : nom du contexte */ +/* (I) Debug_Mode : mode d'affichage des messages d'erreur */ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* Ouverture d'une instance de la librairie */ -/*------------------------------------------------------------------------------*/ -/* (I) Instance : numéro de l'instance de la librairie */ -/* (I) Context : nom du contexte */ -/* (I) Debug_Mode : mode d'affichage des messages d'erreur */ -/*------------------------------------------------------------------------------*/ DST_Status DS_Library_Open_I ( int Instance, const char * Context, DST_Flags Debug_Mode ) { DST_Status rc; @@ -57,7 +90,7 @@ DST_Status DS_Library_Open_I ( int Instance, const char * Context, DST_Flags Deb Lors de la première ouverture de la librairie LIBDATASTR, on crée une structure locale permettant de référencer les data structures ouvertes. - */ + */ if (DS_Open_Counter == 0) { @@ -77,9 +110,12 @@ DST_Status DS_Library_Open_I ( int Instance, const char * Context, DST_Flags Deb return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Fermeture de l'instance de la librairie */ -/*------------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Fermeture de l'instance de la librairie */ +/*----------------------------------------------------------------------------*/ + DST_Status DS_Library_Close_I ( void ) { DST_Status rc; @@ -87,7 +123,7 @@ DST_Status DS_Library_Close_I ( void ) /* A la dernière fermeture de la librairie LIBDATASTR, on détruit la structure locale qui référence les data structures ouvertes. - */ + */ if (DS_Open_Counter == 1) { @@ -117,29 +153,35 @@ DST_Status DS_Library_Close_I ( void ) return rc; } -/*------------------------------------------------------------------------------*/ -/* Définition de la sortie standard des messages d'erreur de la librairie */ -/*------------------------------------------------------------------------------*/ -/* (I) Out : flux de sortie des messages d'erreur */ -/*------------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Définition de la sortie standard des messages d'erreur de la librairie */ +/*----------------------------------------------------------------------------*/ +/* (I) Out : flux de sortie des messages d'erreur */ +/*----------------------------------------------------------------------------*/ + DST_Status DS_Library_Stderr_Set_I ( FILE * Out ) { DS_stderr = Out; return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Création / ouverture d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) DS_Name : nom de la structure */ -/* (O) Root : adresse du pointeur sur la racine de la structure */ -/* (I) Type : type de la structure de données */ -/* (I) Manager_FileName : nom du fichier qui définit les fonctions manager */ -/* (I) Segment_Size : taille ds segments du heap sous-jacent */ -/* (I) Open_Mode : mode d'ouverture de la structure */ -/* (I) Own_Values : indique si la structure possède ses valeurs */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Open_I ( const char * DS_Name, NDT_Root ** Root,\ + + +/*----------------------------------------------------------------------------*/ +/* Création / ouverture d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) DS_Name : nom de la structure */ +/* (O) Root : adresse du pointeur sur la racine de la structure */ +/* (I) Type : type de la structure de données */ +/* (I) Manager_FileName : nom du fichier qui définit les fonctions manager */ +/* (I) Segment_Size : taille ds segments du heap sous-jacent */ +/* (I) Open_Mode : mode d'ouverture de la structure */ +/* (I) Own_Values : indique si la structure possède ses valeurs */ +/*----------------------------------------------------------------------------*/ + +DST_Status DS_DataStruct_Open_I ( const char * DS_Name, NDT_Root ** Root, \ NDT_DataStruct_Type Type, const char * Manager_FileName, \ size_t Segment_Size, DST_Flags Open_Mode, int Own_Values ) { @@ -181,7 +223,7 @@ DST_Status DS_DataStruct_Open_I ( const char * DS_Name, NDT_Root ** Root,\ { case 1: - /*--------------- Création d'une nouvelle data structure dans un heap existant ---------------*/ + /*--------------- Création d'une nouvelle data structure dans un heap existant -------------*/ /* Ouverture du heap en écriture */ @@ -264,7 +306,7 @@ DST_Status DS_DataStruct_Open_I ( const char * DS_Name, NDT_Root ** Root,\ case 2: - /*--------------- Ouverture d'une data structure existante --------------------*/ + /*--------------- Ouverture d'une data structure existante ------------------*/ /* Si la structure a déjà été ouverte, on ne recommence pas */ @@ -314,7 +356,7 @@ DST_Status DS_DataStruct_Open_I ( const char * DS_Name, NDT_Root ** Root,\ case 3: - /*--------------- Création d'une nouvelle structure de données dans un nouveau heap -------------------*/ + /*--------------- Création d'une nouvelle structure de données dans un nouveau heap -----------------*/ if (!Manager_FileName) { @@ -472,13 +514,15 @@ DST_Status DS_DataStruct_Open_I ( const char * DS_Name, NDT_Root ** Root,\ return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Verrouillage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (I) Lock_Mode : type de verrou à poser sur la structure */ -/* (O) Locked : verrou effectif (TRUE ou FALSE) */ -/*------------------------------------------------------------------------------*/ + +/*----------------------------------------------------------------------------*/ +/* Verrouillage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (I) Lock_Mode : type de verrou à poser sur la structure */ +/* (O) Locked : verrou effectif (TRUE ou FALSE) */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Lock_I ( NDT_Root * Root, DST_Flags Lock_Mode, int * Locked ) { DST_Status rc; @@ -486,7 +530,7 @@ DST_Status DS_DataStruct_Lock_I ( NDT_Root * Root, DST_Flags Lock_Mode, int * Lo char * Heap_Name = ((DST_RootDesc *)(Root->User))->Heap_Name; /* Réouverture du heap sous-jacent (rafraîchissement des segments) + verrouillage */ - +/* rc = SM_Heap_Open (Heap_Name, &Heap, 0, SMD_OPEN | Lock_Mode, Locked); if (rc != SMS_OK) { @@ -500,11 +544,12 @@ DST_Status DS_DataStruct_Lock_I ( NDT_Root * Root, DST_Flags Lock_Mode, int * Lo return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Déverrouillage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Déverrouillage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Unlock_I ( NDT_Root * Root ) { DST_Status rc; @@ -532,12 +577,13 @@ DST_Status DS_DataStruct_Unlock_I ( NDT_Root * Root ) return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Fermeture d'une structure de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fermeture d'une structure de données */ +/*----------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données à fermer */ -/* (I) Close_Mode : mode de fermeture de la structure (destruction ou non) */ -/*------------------------------------------------------------------------------*/ +/* (I) Close_Mode : mode de fermeture de la structure (destruction ou non) */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) { DST_Status rc; @@ -554,13 +600,13 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) else DS_Name = Heap_Name; if (Close_Mode == DSD_DESTROY) /* Destruction de la data structure */ - { +/* { /* La data structure est-elle propriétaire du heap sous-jacent ? */ - +/* if (RootDesc->Heap_Owner == TRUE) { /* On vérifie qu'aucun autre processus n'a ouvert la data structure */ - +/* rc = DS_Semaphore_Operate (RootDesc->OpenSemID, DS_SemOp_Destroy, 2); if (rc != DSS_OK) { @@ -572,7 +618,7 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) } /* On supprime la structure proprement (toutes les valeurs sont supprimées les unes après les autres) */ - +/* rc = ND_DataStruct_Close (Root); if (rc != NDS_OK) { @@ -583,11 +629,11 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) } /* Suppression du sémaphore */ - +/* semctl (RootDesc->OpenSemID, 0, IPC_RMID, Sem_Ctl); /* On supprime maintenant le heap */ - +/* rc = SM_Heap_End (Heap_Name); if (rc != SMS_OK) { @@ -604,8 +650,8 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) on ne peut pas garantir qu'aucun autre processus ne l'a ouverte. On la supprime donc sans contrôle. - */ - + */ +/* rc = ND_DataStruct_Close (Root); if (rc != NDS_OK) { @@ -619,9 +665,9 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) } } else /* Fermeture simple de la data structure */ - { +/* { /* On décrémente le sémaphore qui compte le nombre de processus ayant ouvert la data structure */ - +/* rc = DS_Semaphore_Operate (RootDesc->OpenSemID, DS_SemOp_Close, 1); if (rc != DSS_OK) { @@ -632,7 +678,7 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) } /* Fermeture simple du heap */ - +/* rc = SM_Heap_IsOpen (Heap_Name, &Heap); if (rc == SMS_YES) { @@ -648,7 +694,7 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) } /* Suppression de la data structure de la liste des structures ouvertes */ - +/* To_Remove.Name = DS_Name; rc = ND_Value_Remove (OpenedDS_List, &To_Remove, (void **)&Opened_DataStruct); if (rc == NDS_OK) ND_Value_Free (OpenedDS_List, Opened_DataStruct); @@ -656,25 +702,26 @@ DST_Status DS_DataStruct_Close_I ( NDT_Root * Root, DST_Flags Close_Mode ) return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Affiche les informations d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root: pointeur sur la racine de la structure de données */ -/* (I) Out : flux de sortie de l'affichage */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Affiche les informations d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root: pointeur sur la racine de la structure de données */ +/* (I) Out : flux de sortie de l'affichage */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Info_Print_I ( NDT_Root * Root, FILE * Out ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); @@ -688,7 +735,7 @@ DST_Status DS_DataStruct_Info_Print_I ( NDT_Root * Root, FILE * Out ) } /* Affichage des informations sur la structure */ - +/* rc = ND_DataStruct_Info_Print (Root, Out); if (rc != NDS_OK) { @@ -701,24 +748,25 @@ DST_Status DS_DataStruct_Info_Print_I ( NDT_Root * Root, FILE * Out ) return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Réorganisation d'une structure de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Réorganisation d'une structure de données */ +/*----------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données à réorganiser */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Reorg_I ( NDT_Root * Root ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); @@ -732,11 +780,11 @@ DST_Status DS_DataStruct_Reorg_I ( NDT_Root * Root ) } /* On rend la structure invalide, le temps de sa réorganisation */ - +/* RootDesc->Valid = FALSE; /* Réorganisation de la node structure */ - +/* rc = ND_DataStruct_Reorg (Root); if (rc != NDS_OK) { @@ -751,33 +799,34 @@ DST_Status DS_DataStruct_Reorg_I ( NDT_Root * Root ) } /* On rend la structure à nouveau valide */ - +/* RootDesc->Valid = TRUE; return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* 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 à parcourir */ -/* (I) Command : commande à exécuter sur chaque noeud traversé */ -/* (I) Data : pointeur de données utilisateur */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 à parcourir*/ +/* (I) Command : commande à exécuter sur chaque noeud traversé */ +/* (I) Data : pointeur de données utilisateur */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Traverse_I ( NDT_Root * Root, NDT_Command Command, void * Data ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); @@ -791,7 +840,7 @@ DST_Status DS_DataStruct_Traverse_I ( NDT_Root * Root, NDT_Command Command, void } /* On rend éventuellement la structure invalide le temps de sa traversée */ - +/* switch ((int)Command) { case NDD_CMD_PRINT_VALUE: @@ -803,7 +852,7 @@ DST_Status DS_DataStruct_Traverse_I ( NDT_Root * Root, NDT_Command Command, void } /* Traversée de la node structure */ - +/* rc = ND_DataStruct_Traverse (Root, Command, Data); if (rc != NDS_OK) { @@ -816,31 +865,32 @@ DST_Status DS_DataStruct_Traverse_I ( NDT_Root * Root, NDT_Command Command, void } /* On rend la structure valide */ - +/* RootDesc->Valid = TRUE; return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Convert_I ( NDT_Root * Root, NDT_DataStruct_Type Target_Type ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); @@ -854,11 +904,11 @@ DST_Status DS_DataStruct_Convert_I ( NDT_Root * Root, NDT_DataStruct_Type Target } /* On rend la structure invalide le temps de sa conversion */ - +/* RootDesc->Valid = FALSE; /* Conversion de la node structure */ - +/* rc = ND_DataStruct_Convert (Root, Target_Type); if (rc != NDS_OK) { @@ -871,31 +921,33 @@ DST_Status DS_DataStruct_Convert_I ( NDT_Root * Root, NDT_DataStruct_Type Target } /* On rend la structure à nouveau valide */ - +/* RootDesc->Valid = TRUE; return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Affichage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données à afficher */ -/* (I) Out : flux de sortie */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Affichage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données à afficher */ +/* (I) Out : flux de sortie */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Print_I ( NDT_Root * Root, FILE * Out ) { return DS_DataStruct_Traverse_I (Root, NDD_CMD_PRINT_VALUE, Out); } -/*------------------------------------------------------------------------------*/ -/* Fonction de vérification / réparation d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (O) Nb_Detected : pointeur sur le nombre d'erreurs détectées */ -/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */ -/* (I) Out : flux de sortie du rapport */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fonction de vérification / réparation d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (O) Nb_Detected : pointeur sur le nombre d'erreurs détectées */ +/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */ +/* (I) Out : flux de sortie du rapport */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, int * Nb_Corrected, FILE * Out ) { DST_Status rc; @@ -908,7 +960,7 @@ DST_Status DS_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, int * Nb_ Heap_Name = RootDesc->Heap_Name; /* On sauvegarde l'état de verrouillage précédent */ - +/* rc = SM_Heap_IsOpen (Heap_Name, &Heap); if (rc != SMS_YES) { @@ -921,7 +973,7 @@ DST_Status DS_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, int * Nb_ Previous_Lock = Heap->Lock_Mode; /* Verrouillage de la data structure en écriture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_WRITE, &Locked); if (rc != DSS_OK) { @@ -932,7 +984,7 @@ DST_Status DS_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, int * Nb_ } /* Vérification du heap sous-jacent à la data structure */ - +/* rc = SM_Heap_Check (Heap, Nb_Detected, Nb_Corrected, Out); if (rc != SMS_OK) { @@ -944,24 +996,24 @@ DST_Status DS_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, int * Nb_ else { /* Vérification de la structure de noeuds */ - +/* fprintf (Out, "Checking the node structure ...\n"); rc = ND_DataStruct_Check (Root, Nb_Detected, Nb_Corrected, Out); } /* On valide ou invalide la structure selon le résultat */ - +/* if (*Nb_Corrected == *Nb_Detected) RootDesc->Valid = TRUE; else RootDesc->Valid = FALSE; /* Retour au mode de verrouillage précédent */ - +/* if (Previous_Lock == SMD_UNDEF) DS_DataStruct_Unlock_I (Root); else DS_DataStruct_Lock_I (Root, Previous_Lock, &Locked); /* Affichage du résultat de la procédure de vérification */ - +/* if (*Nb_Detected) { fprintf (Out, "%d/%d error(s) corrected in the data structure\n", *Nb_Corrected, *Nb_Detected); @@ -973,25 +1025,26 @@ DST_Status DS_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, int * Nb_ return rc; } -/*------------------------------------------------------------------------------*/ -/* Affiche la structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (I) Out : flux de sortie */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Affiche la structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (I) Out : flux de sortie */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Dump_I ( NDT_Root * Root, FILE * Out ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); if (rc != DSS_OK) @@ -1004,7 +1057,7 @@ DST_Status DS_DataStruct_Dump_I ( NDT_Root * Root, FILE * Out ) } /* Affichage de la node structure */ - +/* rc = ND_DataStruct_Dump (Root, Out); if (rc != NDS_OK) { @@ -1017,25 +1070,26 @@ DST_Status DS_DataStruct_Dump_I ( NDT_Root * Root, FILE * Out ) return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_First_Get_I ( NDT_Root * Root, NDT_Node ** Node ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); if (rc != DSS_OK) @@ -1048,31 +1102,32 @@ DST_Status DS_Node_First_Get_I ( NDT_Root * Root, NDT_Node ** Node ) } /* Récupération du premier noeud */ - +/* rc = ND_Node_First_Get (Root, Node); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Last_Get_I ( NDT_Root * Root, NDT_Node ** Node ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); if (rc != DSS_OK) @@ -1085,30 +1140,31 @@ DST_Status DS_Node_Last_Get_I ( NDT_Root * Root, NDT_Node ** Node ) } /* Récupération du dernier noeud */ - +/* rc = ND_Node_Last_Get (Root, Node); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Next_Get_I ( NDT_Node * Node, NDT_Node ** Next_Node ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Node->Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Node->Root, &Nb_Detected, &Nb_Corrected, DS_stderr); @@ -1122,31 +1178,32 @@ DST_Status DS_Node_Next_Get_I ( NDT_Node * Node, NDT_Node ** Next_Node ) } /* Récupération du noeud suivant */ - +/* rc = ND_Node_Next_Get (Node, Next_Node); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Previous_Get_I ( NDT_Node * Node, NDT_Node ** Prev_Node ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Node->Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Node->Root, &Nb_Detected, &Nb_Corrected, DS_stderr); @@ -1160,31 +1217,32 @@ DST_Status DS_Node_Previous_Get_I ( NDT_Node * Node, NDT_Node ** Prev_Node ) } /* Récupération du noeud précédent */ - +/* rc = ND_Node_Previous_Get (Node, Prev_Node); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Add_I ( NDT_Root * Root, NDT_Node * Node ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); if (rc != DSS_OK) @@ -1197,11 +1255,11 @@ DST_Status DS_Node_Add_I ( NDT_Root * Root, NDT_Node * Node ) } /* On rend la structure invalide le temps de l'ajout */ - +/* RootDesc->Valid = FALSE; /* Ajout du noeud */ - +/* rc = ND_Node_Add (Root, Node); if (rc != NDS_OK) { @@ -1214,17 +1272,18 @@ DST_Status DS_Node_Add_I ( NDT_Root * Root, NDT_Node * Node ) } /* On rend la structure à nouveau valide */ - +/* RootDesc->Valid = TRUE; return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Suppression d'un noeud dans une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Node : pointeur sur le noeud à supprimer */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Suppression d'un noeud dans une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Node : pointeur sur le noeud à supprimer */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Remove_I ( NDT_Node * Node ) { DST_Status rc; @@ -1234,13 +1293,13 @@ DST_Status DS_Node_Remove_I ( NDT_Node * Node ) Root = Node->Root; /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); if (rc != DSS_OK) @@ -1253,11 +1312,11 @@ DST_Status DS_Node_Remove_I ( NDT_Node * Node ) } /* On rend la structure invalide le temps de la suppression du noeud */ - +/* RootDesc->Valid = FALSE; /* Suppression dans la node structure */ - +/* rc = ND_Node_Remove (Node); if (rc != NDS_OK) { @@ -1270,20 +1329,21 @@ DST_Status DS_Node_Remove_I ( NDT_Node * Node ) } /* On rend la structure à nouveau valide */ - +/* RootDesc->Valid = TRUE; return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de l'abre */ -/* (O) Node : adresse du pointeur sur le noeud à récuperer */ -/* (I) Value : pointeur sur la valeur à rechercher */ -/* (I) Data : pointeur de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de l'abre */ +/* (O) Node : adresse du pointeur sur le noeud à récuperer */ +/* (I) Value : pointeur sur la valeur à rechercher */ +/* (I) Data : pointeur de données */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Find_I ( NDT_Root * Root, NDT_Node ** Node, void * Value, void * Data ) { DST_Status rc; @@ -1292,13 +1352,13 @@ DST_Status DS_Node_Find_I ( NDT_Root * Root, NDT_Node ** Node, void * Value, voi *Node = NULL; /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); if (rc != DSS_OK) @@ -1311,30 +1371,31 @@ DST_Status DS_Node_Find_I ( NDT_Root * Root, NDT_Node ** Node, void * Value, voi } /* Recherche dans la node structure */ - +/* rc = ND_Node_Find (Root, Node, Value, Data); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Alloc_I ( NDT_Root * Root, void ** Value, ... ) { DST_Status rc; va_list Args; /* Récupération des arguments pour l'allocation de la valeur */ - +/* va_start (Args, Value); /* Appel du manager */ - +/* rc = ND_Manager_Exec (Root->Manager, NDD_CMD_MAKE_VALUE, Root, Value, Args); va_end (Args); @@ -1342,25 +1403,26 @@ DST_Status DS_Value_Alloc_I ( NDT_Root * Root, void ** Value, ... ) return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 à la structure de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 à la structure de données */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Add_I ( NDT_Root * Root, void * Value ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); if (rc != DSS_OK) @@ -1373,11 +1435,11 @@ DST_Status DS_Value_Add_I ( NDT_Root * Root, void * Value ) } /* On rend la structure invalide le temps de l'ajout */ - +/* RootDesc->Valid = FALSE; /* Ajout de la valeur */ - +/* rc = ND_Value_Add (Root, Value); if (rc != NDS_OK) { @@ -1390,32 +1452,33 @@ DST_Status DS_Value_Add_I ( NDT_Root * Root, void * Value ) } /* On rend la structure à nouveau valide */ - +/* RootDesc->Valid = TRUE; return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Remove_I ( NDT_Root * Root, void * Reference_Value, void ** Removed_Value ) { DST_Status rc; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* On vérifie que la data structure est valide */ - +/* if (RootDesc->Valid == FALSE) { int Nb_Detected, Nb_Corrected; /* On vérifie la structure */ - +/* Nb_Detected = Nb_Corrected = 0; rc = DS_DataStruct_Check_L (Root, &Nb_Detected, &Nb_Corrected, DS_stderr); if (rc != DSS_OK) @@ -1428,11 +1491,11 @@ DST_Status DS_Value_Remove_I ( NDT_Root * Root, void * Reference_Value, void ** } /* On rend la structure invalide le temps de la suppression de valeur */ - +/* RootDesc->Valid = FALSE; /* Suppression du noeud correspondant à la valeur de référence */ - +/* rc = ND_Value_Remove (Root, Reference_Value, Removed_Value); if (rc != NDS_OK) { @@ -1445,145 +1508,156 @@ DST_Status DS_Value_Remove_I ( NDT_Root * Root, void * Reference_Value, void ** } /* On rend la structure à nouveau valide */ - +/* RootDesc->Valid = TRUE; return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Free_I ( NDT_Root * Root, void * Value ) { return ND_Value_Free (Root, Value); } -/*------------------------------------------------------------------------------*/ -/* Allocation de mémoire pour une structure de données : */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données */ -/* (I) Size : taille mémoire à allouer */ -/* (O) Ptr : adresse du pointeur sur la zone de données allouée */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Allocation de mémoire pour une structure de données : */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données */ +/* (I) Size : taille mémoire à allouer */ +/* (O) Ptr : adresse du pointeur sur la zone de données allouée */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Alloc_I ( NDT_Root * Root, size_t Size, void ** Ptr ) { return DS_DataStruct_Alloc (Size, Ptr, Root->User); } -/*------------------------------------------------------------------------------*/ -/* Désallocation d'une ressource pour une structure de données : */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données */ -/* (I) Ptr : pointeur sur la zone à désallouer */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Désallocation d'une ressource pour une structure de données : */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données */ +/* (I) Ptr : pointeur sur la zone à désallouer */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Free_I ( NDT_Root * Root, void * Ptr ) { return DS_DataStruct_Free (Ptr, Root->User); } -/*------------------------------------------------------------------------------*/ -/* FONCTIONS OPTIMISATION MOYENNE (DS_MODE = 1) */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* FONCTIONS OPTIMISATION MOYENNE (DS_MODE = 1) */ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* Ouverture d'une instance de la librairie */ -/*------------------------------------------------------------------------------*/ -/* (I) Instance : numéro de l'instance de la librairie */ -/* (I) Context : nom du contexte */ -/* (I) Debug_Mode : mode d'affichage des messages d'erreur */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Ouverture d'une instance de la librairie */ +/*----------------------------------------------------------------------------*/ +/* (I) Instance : numéro de l'instance de la librairie */ +/* (I) Context : nom du contexte */ +/* (I) Debug_Mode : mode d'affichage des messages d'erreur */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Library_Open_L ( int Instance, const char * Context, DST_Flags Debug_Mode ) { return DS_Library_Open_I (Instance, Context, Debug_Mode); } -/*------------------------------------------------------------------------------*/ -/* Fermeture de l'instance de la librairie */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fermeture de l'instance de la librairie */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Library_Close_L ( void ) { return DS_Library_Close_I (); } -/*------------------------------------------------------------------------------*/ -/* Définition de la sortie standard des messages d'erreur de la librairie */ -/*------------------------------------------------------------------------------*/ -/* (I) Out : flux de sortie des messages d'erreur */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Définition de la sortie standard des messages d'erreur de la librairie */ +/*----------------------------------------------------------------------------*/ +/* (I) Out : flux de sortie des messages d'erreur */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Library_Stderr_Set_L ( FILE * Out ) { return DS_Library_Stderr_Set_I (Out); } -/*------------------------------------------------------------------------------*/ -/* Création / ouverture d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) DS_Name : nom de la structure */ -/* (O) Root : adresse du pointeur sur la racine de la structure */ -/* (I) Type : type de la structure de données */ -/* (I) Manager_FileName : nom du fichier qui définit les fonctions manager */ -/* (I) Segment_Size : taille ds segments du heap sous-jacent */ -/* (I) Open_Mode : mode d'ouverture de la structure */ -/* (I) Own_Values : indique si la structure possède ses valeurs */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Open_L ( const char * DS_Name, NDT_Root ** Root,\ +/*----------------------------------------------------------------------------*/ +/* Création / ouverture d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) DS_Name : nom de la structure */ +/* (O) Root : adresse du pointeur sur la racine de la structure */ +/* (I) Type : type de la structure de données */ +/* (I) Manager_FileName : nom du fichier qui définit les fonctions manager */ +/* (I) Segment_Size : taille ds segments du heap sous-jacent */ +/* (I) Open_Mode : mode d'ouverture de la structure */ +/* (I) Own_Values : indique si la structure possède ses valeurs */ +/*----------------------------------------------------------------------------*/ +/* +DST_Status DS_DataStruct_Open_L ( const char * DS_Name, NDT_Root ** Root, \ NDT_DataStruct_Type Type, const char * Manager_FileName, \ size_t Segment_Size, DST_Flags Open_Mode, int Own_Values ) { return DS_DataStruct_Open_I (DS_Name, Root, Type, Manager_FileName, Segment_Size, Open_Mode, Own_Values); } -/*------------------------------------------------------------------------------*/ -/* Verrouillage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (I) Lock_Mode : type de verrou à poser sur la structure */ -/* (O) Locked : verrou effectif (TRUE ou FALSE) */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Verrouillage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (I) Lock_Mode : type de verrou à poser sur la structure */ +/* (O) Locked : verrou effectif (TRUE ou FALSE) */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Lock_L ( NDT_Root * Root, DST_Flags Lock_Mode, int * Locked ) { return DS_DataStruct_Lock_I (Root, Lock_Mode, Locked); } -/*------------------------------------------------------------------------------*/ -/* Déverrouillage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Déverrouillage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Unlock_L ( NDT_Root * Root ) { return DS_DataStruct_Unlock_I (Root); } -/*------------------------------------------------------------------------------*/ -/* Fermeture d'une structure de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fermeture d'une structure de données */ +/*----------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données à fermer */ -/* (I) Close_Mode : mode de fermeture de la structure (destruction ou non) */ -/*------------------------------------------------------------------------------*/ +/* (I) Close_Mode : mode de fermeture de la structure (destruction ou non) */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Close_L ( NDT_Root * Root, DST_Flags Close_Mode ) { return DS_DataStruct_Close_I (Root, Close_Mode); } -/*------------------------------------------------------------------------------*/ -/* Affiche les informations d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root: pointeur sur la racine de la structure de données */ -/* (I) Out : flux de sortie de l'affichage */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Affiche les informations d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root: pointeur sur la racine de la structure de données */ +/* (I) Out : flux de sortie de l'affichage */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Info_Print_L ( NDT_Root * Root, FILE * Out ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en lecture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_READ, &Locked); if (rc != DSS_OK) { @@ -1596,24 +1670,25 @@ DST_Status DS_DataStruct_Info_Print_L ( NDT_Root * Root, FILE * Out ) rc = DS_DataStruct_Info_Print_I (Root, Out); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* Réorganisation d'une structure de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Réorganisation d'une structure de données */ +/*----------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données à réorganiser */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Reorg_L ( NDT_Root * Root ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en écriture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_WRITE, &Locked); if (rc != DSS_OK) { @@ -1626,20 +1701,21 @@ DST_Status DS_DataStruct_Reorg_L ( NDT_Root * Root ) rc = DS_DataStruct_Reorg_I (Root); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 à parcourir */ -/* (I) Command : commande à exécuter sur chaque noeud traversé */ -/* (I) Data : pointeur de données utilisateur */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 à parcourir*/ +/* (I) Command : commande à exécuter sur chaque noeud traversé */ +/* (I) Data : pointeur de données utilisateur */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Traverse_L ( NDT_Root * Root, NDT_Command Command, void * Data ) { DST_Status rc; @@ -1647,7 +1723,7 @@ DST_Status DS_DataStruct_Traverse_L ( NDT_Root * Root, NDT_Command Command, void int Locked; /* Définition du mode de verrouillage de la data structure selon le type de commande */ - +/* switch ((int)Command) { case NDD_CMD_PRINT_VALUE: @@ -1662,7 +1738,7 @@ DST_Status DS_DataStruct_Traverse_L ( NDT_Root * Root, NDT_Command Command, void } /* Verrouillage de la data structure */ - +/* rc = DS_DataStruct_Lock_I (Root, Lock_Mode, &Locked); if (rc != DSS_OK) { @@ -1676,25 +1752,26 @@ DST_Status DS_DataStruct_Traverse_L ( NDT_Root * Root, NDT_Command Command, void rc = DS_DataStruct_Traverse_I (Root, Command, Data); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Convert_L ( NDT_Root * Root, NDT_DataStruct_Type Target_Type ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en écriture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_WRITE, &Locked); if (rc != DSS_OK) { @@ -1707,49 +1784,52 @@ DST_Status DS_DataStruct_Convert_L ( NDT_Root * Root, NDT_DataStruct_Type Target rc = DS_DataStruct_Convert_I (Root, Target_Type); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* Affichage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données à afficher */ -/* (I) Out : flux de sortie */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Affichage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données à afficher */ +/* (I) Out : flux de sortie */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Print_L ( NDT_Root * Root, FILE * Out ) { return DS_DataStruct_Traverse_L (Root, NDD_CMD_PRINT_VALUE, Out); } -/*------------------------------------------------------------------------------*/ -/* Fonction de vérification / réparation d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (O) Nb_Detected : pointeur sur le nombre d'erreurs détectées */ -/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */ -/* (I) Out : flux de sortie du rapport */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fonction de vérification / réparation d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (O) Nb_Detected : pointeur sur le nombre d'erreurs détectées */ +/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */ +/* (I) Out : flux de sortie du rapport */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Check_L ( NDT_Root * Root, int * Nb_Detected, int * Nb_Corrected, FILE * Out ) { return DS_DataStruct_Check_I (Root, Nb_Detected, Nb_Corrected, Out); } -/*------------------------------------------------------------------------------*/ -/* Affiche la structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (I) Out : flux de sortie */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Affiche la structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (I) Out : flux de sortie */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Dump_L ( NDT_Root * Root, FILE * Out ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en lecture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_READ, &Locked); if (rc != DSS_OK) { @@ -1762,25 +1842,26 @@ DST_Status DS_DataStruct_Dump_L ( NDT_Root * Root, FILE * Out ) rc = DS_DataStruct_Dump_I (Root, Out); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_First_Get_L ( NDT_Root * Root, NDT_Node ** Node ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en lecture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_READ, &Locked); if (rc != DSS_OK) { @@ -1793,25 +1874,26 @@ DST_Status DS_Node_First_Get_L ( NDT_Root * Root, NDT_Node ** Node ) rc = DS_Node_First_Get_I (Root, Node); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Last_Get_L ( NDT_Root * Root, NDT_Node ** Node ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en lecture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_READ, &Locked); if (rc != DSS_OK) { @@ -1824,24 +1906,25 @@ DST_Status DS_Node_Last_Get_L ( NDT_Root * Root, NDT_Node ** Node ) rc = DS_Node_Last_Get_I (Root, Node); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Next_Get_L ( NDT_Node * Node, NDT_Node ** Next_Node ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en lecture */ - +/* rc = DS_DataStruct_Lock_I (Node->Root, SMD_READ, &Locked); if (rc != DSS_OK) { @@ -1854,25 +1937,26 @@ DST_Status DS_Node_Next_Get_L ( NDT_Node * Node, NDT_Node ** Next_Node ) rc = DS_Node_Next_Get_I (Node, Next_Node); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Node->Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Previous_Get_L ( NDT_Node * Node, NDT_Node ** Prev_Node ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en lecture */ - +/* rc = DS_DataStruct_Lock_I (Node->Root, SMD_READ, &Locked); if (rc != DSS_OK) { @@ -1885,25 +1969,26 @@ DST_Status DS_Node_Previous_Get_L ( NDT_Node * Node, NDT_Node ** Prev_Node ) rc = DS_Node_Previous_Get_I (Node, Prev_Node); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Node->Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Add_L ( NDT_Root * Root, NDT_Node * Node ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en écriture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_WRITE, &Locked); if (rc != DSS_OK) { @@ -1916,17 +2001,18 @@ DST_Status DS_Node_Add_L ( NDT_Root * Root, NDT_Node * Node ) rc = DS_Node_Add_I (Root, Node); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* Suppression d'un noeud dans une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Node : pointeur sur le noeud à supprimer */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Suppression d'un noeud dans une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Node : pointeur sur le noeud à supprimer */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Remove_L ( NDT_Node * Node ) { DST_Status rc; @@ -1934,7 +2020,7 @@ DST_Status DS_Node_Remove_L ( NDT_Node * Node ) NDT_Root * Root = Node->Root; /* Verrouillage de la data structure en écriture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_WRITE, &Locked); if (rc != DSS_OK) { @@ -1947,27 +2033,28 @@ DST_Status DS_Node_Remove_L ( NDT_Node * Node ) rc = DS_Node_Remove_I (Node); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de l'abre */ -/* (O) Node : adresse du pointeur sur le noeud à récuperer */ -/* (I) Value : pointeur sur la valeur à rechercher */ -/* (I) Data : pointeur de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de l'abre */ +/* (O) Node : adresse du pointeur sur le noeud à récuperer */ +/* (I) Value : pointeur sur la valeur à rechercher */ +/* (I) Data : pointeur de données */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Find_L ( NDT_Root * Root, NDT_Node ** Node, void * Value, void * Data ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en lecture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_READ, &Locked); if (rc != DSS_OK) { @@ -1980,30 +2067,31 @@ DST_Status DS_Node_Find_L ( NDT_Root * Root, NDT_Node ** Node, void * Value, voi rc = DS_Node_Find_I (Root, Node, Value, Data); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Alloc_L ( NDT_Root * Root, void ** Value, ... ) { DST_Status rc; va_list Args; /* Récupération des arguments pour l'allocation de la valeur */ - +/* va_start (Args, Value); /* Appel du manager */ - +/* rc = ND_Manager_Exec (Root->Manager, NDD_CMD_MAKE_VALUE, Root, Value, Args); va_end (Args); @@ -2011,19 +2099,20 @@ DST_Status DS_Value_Alloc_L ( NDT_Root * Root, void ** Value, ... ) return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 à la structure de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 à la structure de données */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Add_L ( NDT_Root * Root, void * Value ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en écriture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_WRITE, &Locked); if (rc != DSS_OK) { @@ -2034,30 +2123,31 @@ DST_Status DS_Value_Add_L ( NDT_Root * Root, void * Value ) } /* Ajout de la valeur */ - +/* rc = DS_Value_Add_I (Root, Value); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Remove_L ( NDT_Root * Root, void * Reference_Value, void ** Removed_Value ) { DST_Status rc; int Locked; /* Verrouillage de la data structure en écriture */ - +/* rc = DS_DataStruct_Lock_I (Root, SMD_WRITE, &Locked); if (rc != DSS_OK) { @@ -2070,92 +2160,99 @@ DST_Status DS_Value_Remove_L ( NDT_Root * Root, void * Reference_Value, void ** rc = DS_Value_Remove_I (Root, Reference_Value, Removed_Value); /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) DS_DataStruct_Unlock_I (Root); return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Free_L ( NDT_Root * Root, void * Value ) { return ND_Value_Free (Root, Value); } -/*------------------------------------------------------------------------------*/ -/* Allocation de mémoire pour une structure de données : */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données */ -/* (I) Size : taille mémoire à allouer */ -/* (O) Ptr : adresse du pointeur sur la zone de données allouée */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Allocation de mémoire pour une structure de données : */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données */ +/* (I) Size : taille mémoire à allouer */ +/* (O) Ptr : adresse du pointeur sur la zone de données allouée */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Alloc_L ( NDT_Root * Root, size_t Size, void ** Ptr ) { return DS_DataStruct_Alloc (Size, Ptr, Root->User); } -/*------------------------------------------------------------------------------*/ -/* Désallocation d'une ressource pour une structure de données : */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données */ -/* (I) Ptr : pointeur sur la zone à désallouer */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Désallocation d'une ressource pour une structure de données : */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données */ +/* (I) Ptr : pointeur sur la zone à désallouer */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Free_L ( NDT_Root * Root, void * Ptr ) { return DS_DataStruct_Free (Ptr, Root->User); } -/*------------------------------------------------------------------------------*/ -/* FONCTIONS SECURISEES (DS_MODE = 0) */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* FONCTIONS SECURISEES (DS_MODE = 0) */ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* Ouverture d'une instance de la librairie */ -/*------------------------------------------------------------------------------*/ -/* (I) Instance : numéro de l'instance de la librairie */ -/* (I) Context : nom du contexte */ -/* (I) Debug_Mode : mode d'affichage des messages d'erreur */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Ouverture d'une instance de la librairie */ +/*----------------------------------------------------------------------------*/ +/* (I) Instance : numéro de l'instance de la librairie */ +/* (I) Context : nom du contexte */ +/* (I) Debug_Mode : mode d'affichage des messages d'erreur */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Library_Open_CL ( int Instance, const char * Context, DST_Flags Debug_Mode ) { return DS_Library_Open_I (Instance, Context, Debug_Mode ); } -/*------------------------------------------------------------------------------*/ -/* Fermeture de l'instance de la librairie */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fermeture de l'instance de la librairie */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Library_Close_CL ( void ) { return DS_Library_Close_I (); } -/*------------------------------------------------------------------------------*/ -/* Définition de la sortie standard des messages d'erreur de la librairie */ -/*------------------------------------------------------------------------------*/ -/* (I) Out : flux de sortie des messages d'erreur */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Définition de la sortie standard des messages d'erreur de la librairie */ +/*----------------------------------------------------------------------------*/ +/* (I) Out : flux de sortie des messages d'erreur */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Library_Stderr_Set_CL ( FILE * Out ) { return DS_Library_Stderr_Set_I (Out); } -/*------------------------------------------------------------------------------*/ -/* Création / ouverture d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) DS_Name : nom de la structure */ -/* (O) Root : adresse du pointeur sur la racine de la structure */ -/* (I) Type : type de la structure de données */ -/* (I) Manager_FileName : nom du fichier qui définit les fonctions manager */ -/* (I) Segment_Size : taille ds segments du heap sous-jacent */ -/* (I) Open_Mode : mode d'ouverture de la structure */ -/* (I) Own_Values : indique si la structure possède ses valeurs */ -/*------------------------------------------------------------------------------*/ -DST_Status DS_DataStruct_Open_CL ( const char * DS_Name, NDT_Root ** Root,\ +/*----------------------------------------------------------------------------*/ +/* Création / ouverture d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) DS_Name : nom de la structure */ +/* (O) Root : adresse du pointeur sur la racine de la structure */ +/* (I) Type : type de la structure de données */ +/* (I) Manager_FileName : nom du fichier qui définit les fonctions manager */ +/* (I) Segment_Size : taille ds segments du heap sous-jacent */ +/* (I) Open_Mode : mode d'ouverture de la structure */ +/* (I) Own_Values : indique si la structure possède ses valeurs */ +/*----------------------------------------------------------------------------*/ +/* +DST_Status DS_DataStruct_Open_CL ( const char * DS_Name, NDT_Root ** Root, \ NDT_DataStruct_Type Type, const char * Manager_FileName, \ size_t Segment_Size, DST_Flags Open_Mode, int Own_Values ) { @@ -2186,13 +2283,14 @@ DST_Status DS_DataStruct_Open_CL ( const char * DS_Name, NDT_Root ** Root,\ return DS_DataStruct_Open_I (DS_Name, Root, Type, Manager_FileName, Segment_Size, Open_Mode, Own_Values); } -/*------------------------------------------------------------------------------*/ -/* Verrouillage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (I) Lock_Mode : type de verrou à poser sur la structure */ -/* (O) Locked : verrou effectif (TRUE ou FALSE) */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Verrouillage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (I) Lock_Mode : type de verrou à poser sur la structure */ +/* (O) Locked : verrou effectif (TRUE ou FALSE) */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Lock_CL ( NDT_Root * Root, DST_Flags Lock_Mode, int * Locked ) { if (!Root) @@ -2214,11 +2312,12 @@ DST_Status DS_DataStruct_Lock_CL ( NDT_Root * Root, DST_Flags Lock_Mode, int * L return DS_DataStruct_Lock_I (Root, Lock_Mode, Locked); } -/*------------------------------------------------------------------------------*/ -/* Déverrouillage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Déverrouillage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Unlock_CL ( NDT_Root * Root ) { if (!Root) @@ -2232,12 +2331,13 @@ DST_Status DS_DataStruct_Unlock_CL ( NDT_Root * Root ) return DS_DataStruct_Unlock_I (Root); } -/*------------------------------------------------------------------------------*/ -/* Fermeture d'une structure de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fermeture d'une structure de données */ +/*----------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données à fermer */ -/* (I) Close_Mode : mode de fermeture de la structure (destruction ou non) */ -/*------------------------------------------------------------------------------*/ +/* (I) Close_Mode : mode de fermeture de la structure (destruction ou non) */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Close_CL ( NDT_Root * Root, DST_Flags Close_Mode ) { if (!Root) @@ -2251,12 +2351,13 @@ DST_Status DS_DataStruct_Close_CL ( NDT_Root * Root, DST_Flags Close_Mode ) return DS_DataStruct_Close_I (Root, Close_Mode); } -/*------------------------------------------------------------------------------*/ -/* Affiche les informations d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root: pointeur sur la racine de la structure de données */ -/* (I) Out : flux de sortie de l'affichage */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Affiche les informations d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root: pointeur sur la racine de la structure de données */ +/* (I) Out : flux de sortie de l'affichage */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Info_Print_CL ( NDT_Root * Root, FILE * Out ) { if (!Root) @@ -2278,11 +2379,12 @@ DST_Status DS_DataStruct_Info_Print_CL ( NDT_Root * Root, FILE * Out ) return DS_DataStruct_Info_Print_L (Root, Out); } -/*------------------------------------------------------------------------------*/ -/* Réorganisation d'une structure de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Réorganisation d'une structure de données */ +/*----------------------------------------------------------------------------*/ /* (I) Root : pointeur sur la racine de la structure de données à réorganiser */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Reorg_CL ( NDT_Root * Root ) { if (!Root) @@ -2296,14 +2398,15 @@ DST_Status DS_DataStruct_Reorg_CL ( NDT_Root * Root ) return DS_DataStruct_Reorg_L (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 à parcourir */ -/* (I) Command : commande à exécuter sur chaque noeud traversé */ -/* (I) Data : pointeur de données utilisateur */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 à parcourir*/ +/* (I) Command : commande à exécuter sur chaque noeud traversé */ +/* (I) Data : pointeur de données utilisateur */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Traverse_CL ( NDT_Root * Root, NDT_Command Command, void * Data ) { if (!Root) @@ -2317,12 +2420,13 @@ DST_Status DS_DataStruct_Traverse_CL ( NDT_Root * Root, NDT_Command Command, voi return DS_DataStruct_Traverse_L (Root, Command, 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Convert_CL ( NDT_Root * Root, NDT_DataStruct_Type Target_Type ) { if (!Root) @@ -2336,25 +2440,27 @@ DST_Status DS_DataStruct_Convert_CL ( NDT_Root * Root, NDT_DataStruct_Type Targe return DS_DataStruct_Convert_L (Root, Target_Type); } -/*------------------------------------------------------------------------------*/ -/* Affichage d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données à afficher */ -/* (I) Out : flux de sortie */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Affichage d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données à afficher */ +/* (I) Out : flux de sortie */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Print_CL ( NDT_Root * Root, FILE * Out ) { return DS_DataStruct_Traverse_CL (Root, NDD_CMD_PRINT_VALUE, Out); } -/*------------------------------------------------------------------------------*/ -/* Fonction de vérification / réparation d'une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (O) Nb_Detected : pointeur sur le nombre d'erreurs détectées */ -/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */ -/* (I) Out : flux de sortie du rapport */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fonction de vérification / réparation d'une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (O) Nb_Detected : pointeur sur le nombre d'erreurs détectées */ +/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */ +/* (I) Out : flux de sortie du rapport */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Check_CL ( NDT_Root * Root, int * Nb_Detected, int * Nb_Corrected, FILE * Out ) { if (!Root) @@ -2384,12 +2490,13 @@ DST_Status DS_DataStruct_Check_CL ( NDT_Root * Root, int * Nb_Detected, int * Nb return DS_DataStruct_Check_I (Root, Nb_Detected, Nb_Corrected, Out); } -/*------------------------------------------------------------------------------*/ -/* Affiche la structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure */ -/* (I) Out : flux de sortie */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Affiche la structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure */ +/* (I) Out : flux de sortie */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Dump_CL ( NDT_Root * Root, FILE * Out ) { if (!Root) @@ -2411,12 +2518,13 @@ DST_Status DS_DataStruct_Dump_CL ( NDT_Root * Root, FILE * Out ) return DS_DataStruct_Dump_L (Root, Out); } -/*------------------------------------------------------------------------------*/ -/* Récupération du premier noeud d'une structure */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine dont on cherche le premier noeud */ -/* (O) First_Node : adresse d'un pointeur sur le premier noeud à récupérer */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Récupération du premier noeud d'une structure */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine dont on cherche le premier noeud */ +/* (O) First_Node : adresse d'un pointeur sur le premier noeud à récupérer */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_First_Get_CL ( NDT_Root * Root, NDT_Node ** First_Node ) { if (!Root) @@ -2438,12 +2546,13 @@ DST_Status DS_Node_First_Get_CL ( NDT_Root * Root, NDT_Node ** First_Node ) return DS_Node_First_Get_L (Root, First_Node); } -/*------------------------------------------------------------------------------*/ -/* Récupération du dernier noeud d'une structure */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la data structure */ -/* (O) Last_Node : adresse d'un pointeur sur le dernier noeud */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Récupération du dernier noeud d'une structure */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la data structure */ +/* (O) Last_Node : adresse d'un pointeur sur le dernier noeud */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Last_Get_CL ( NDT_Root * Root, NDT_Node ** Last_Node ) { if (!Root) @@ -2464,12 +2573,13 @@ DST_Status DS_Node_Last_Get_CL ( NDT_Root * Root, NDT_Node ** Last_Node ) return DS_Node_Last_Get_L (Root, Last_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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Next_Get_CL ( NDT_Node * Node, NDT_Node ** Next_Node ) { if (!Node) @@ -2491,12 +2601,13 @@ DST_Status DS_Node_Next_Get_CL ( NDT_Node * Node, NDT_Node ** Next_Node ) return DS_Node_Next_Get_L (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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Previous_Get_CL ( NDT_Node * Node, NDT_Node ** Prev_Node ) { if (!Node) @@ -2518,12 +2629,13 @@ DST_Status DS_Node_Previous_Get_CL ( NDT_Node * Node, NDT_Node ** Prev_Node ) return DS_Node_Previous_Get_L (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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Add_CL ( NDT_Root * Root, NDT_Node * Node ) { if (!Root) @@ -2545,11 +2657,12 @@ DST_Status DS_Node_Add_CL ( NDT_Root * Root, NDT_Node * Node ) return DS_Node_Add_L (Root, Node); } -/*------------------------------------------------------------------------------*/ -/* Suppression d'un noeud dans une structure de données */ -/*------------------------------------------------------------------------------*/ -/* (I) Node : pointeur sur le noeud à supprimer */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Suppression d'un noeud dans une structure de données */ +/*----------------------------------------------------------------------------*/ +/* (I) Node : pointeur sur le noeud à supprimer */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Remove_CL ( NDT_Node * Node ) { if (!Node) @@ -2563,14 +2676,15 @@ DST_Status DS_Node_Remove_CL ( NDT_Node * Node ) return DS_Node_Remove_L (Node); } -/*------------------------------------------------------------------------------*/ -/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de l'abre */ -/* (O) Node : adresse du pointeur sur le noeud à récuperer */ -/* (I) Value : pointeur sur la valeur à rechercher */ -/* (I) Data : pointeur de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Recherche un noeud dans un arbre et retourne le pointeur sur le noeud */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de l'abre */ +/* (O) Node : adresse du pointeur sur le noeud à récuperer */ +/* (I) Value : pointeur sur la valeur à rechercher */ +/* (I) Data : pointeur de données */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Node_Find_CL ( NDT_Root * Root, NDT_Node ** Node, void * Value, void * Data ) { if (!Root) @@ -2600,13 +2714,14 @@ DST_Status DS_Node_Find_CL ( NDT_Root * Root, NDT_Node ** Node, void * Value, vo return DS_Node_Find_L (Root, Node, Value, 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Alloc_CL ( NDT_Root * Root, void ** Value, ... ) { DST_Status rc; @@ -2627,11 +2742,11 @@ DST_Status DS_Value_Alloc_CL ( NDT_Root * Root, void ** Value, ... ) } /* Récupération des arguments pour l'allocation de la valeur */ - +/* va_start (Args, Value); /* Appel du manager */ - +/* rc = ND_Manager_Exec (Root->Manager, NDD_CMD_MAKE_VALUE, Root, Value, Args); va_end (Args); @@ -2639,12 +2754,13 @@ DST_Status DS_Value_Alloc_CL ( NDT_Root * Root, void ** Value, ... ) return rc; } -/*------------------------------------------------------------------------------*/ -/* 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 à la structure de données */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 à la structure de données */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Add_CL ( NDT_Root * Root, void * Value ) { if (!Root) @@ -2666,13 +2782,14 @@ DST_Status DS_Value_Add_CL ( NDT_Root * Root, void * Value ) return DS_Value_Add_L (Root, 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Remove_CL ( NDT_Root * Root, void * Reference_Value, void ** Removed_Value ) { if (!Root) @@ -2702,12 +2819,13 @@ DST_Status DS_Value_Remove_CL ( NDT_Root * Root, void * Reference_Value, void ** return DS_Value_Remove_L (Root, Reference_Value, 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 */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* 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 */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Value_Free_CL ( NDT_Root * Root, void * Value ) { if (!Root) @@ -2729,13 +2847,14 @@ DST_Status DS_Value_Free_CL ( NDT_Root * Root, void * Value ) return DS_Value_Free_L (Root, Value); } -/*------------------------------------------------------------------------------*/ -/* Allocation de mémoire pour une structure de données : */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données */ -/* (I) Size : taille mémoire à allouer */ -/* (O) Ptr : adresse du pointeur sur la zone de données allouée */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Allocation de mémoire pour une structure de données : */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données */ +/* (I) Size : taille mémoire à allouer */ +/* (O) Ptr : adresse du pointeur sur la zone de données allouée */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Alloc_CL ( NDT_Root * Root, size_t Size, void ** Ptr ) { if (!Root) @@ -2765,12 +2884,13 @@ DST_Status DS_Alloc_CL ( NDT_Root * Root, size_t Size, void ** Ptr ) return DS_Alloc_L (Root, Size, Ptr); } -/*------------------------------------------------------------------------------*/ -/* Désallocation d'une ressource pour une structure de données : */ -/*------------------------------------------------------------------------------*/ -/* (I) Root : pointeur sur la racine de la structure de données */ -/* (I) Ptr : pointeur sur la zone à désallouer */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Désallocation d'une ressource pour une structure de données : */ +/*----------------------------------------------------------------------------*/ +/* (I) Root : pointeur sur la racine de la structure de données */ +/* (I) Ptr : pointeur sur la zone à désallouer */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Free_CL ( NDT_Root * Root, void * Ptr ) { if (!Root) @@ -2792,18 +2912,19 @@ DST_Status DS_Free_CL ( NDT_Root * Root, void * Ptr ) return DS_Free_L (Root, Ptr); } -/*------------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* FONCTIONS PRIVEES */ -/*------------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* FONCTIONS PRIVEES */ +/*----------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* Teste si une data structure a déjà été ouverte par le processus courant : */ -/*------------------------------------------------------------------------------*/ -/* (I) DS_Name : nom de la data structure */ -/* (O) Root : adresse du pointeur sur la racine de la structure */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Teste si une data structure a déjà été ouverte par le processus courant : */ +/*----------------------------------------------------------------------------*/ +/* (I) DS_Name : nom de la data structure */ +/* (O) Root : adresse du pointeur sur la racine de la structure */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_IsOpen ( const char * DS_Name, NDT_Root ** Root ) { DST_Status rc; @@ -2823,9 +2944,10 @@ DST_Status DS_DataStruct_IsOpen ( const char * DS_Name, NDT_Root ** Root ) return DSS_YES; } -/*------------------------------------------------------------------------------*/ -/* Fonction d'allocation attachée à une structure de données : */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fonction d'allocation attachée à une structure de données : */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Alloc ( size_t Size, void ** Ptr, void * Data ) { DST_Status rc; @@ -2844,7 +2966,7 @@ DST_Status DS_DataStruct_Alloc ( size_t Size, void ** Ptr, void * Data ) } /* Verrouillage du heap en écriture */ - +/* rc = SM_Heap_Lock (Heap, SMD_WRITE, &Locked); if (rc != DSS_OK) { @@ -2855,7 +2977,7 @@ DST_Status DS_DataStruct_Alloc ( size_t Size, void ** Ptr, void * Data ) } /* Allocation du chunk */ - +/* rc = SM_Chunk_Alloc (Heap, Size, Ptr); if (rc != SMS_OK) { @@ -2864,15 +2986,16 @@ DST_Status DS_DataStruct_Alloc ( size_t Size, void ** Ptr, void * Data ) } /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) SM_Heap_Unlock (Heap); return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Fonction de désallocation attachée à une structure de données : */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fonction de désallocation attachée à une structure de données : */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_DataStruct_Free ( void * Ptr, void * Data ) { DST_Status rc; @@ -2891,7 +3014,7 @@ DST_Status DS_DataStruct_Free ( void * Ptr, void * Data ) } /* Verrouillage de la data structure en écriture */ - +/* rc = SM_Heap_Lock (Heap, SMD_WRITE, &Locked); if (rc != DSS_OK) { @@ -2902,7 +3025,7 @@ DST_Status DS_DataStruct_Free ( void * Ptr, void * Data ) } /* Désallocation du chunk */ - +/* rc = SM_Chunk_Free (Heap, Ptr); if (rc != SMS_OK) { @@ -2911,23 +3034,25 @@ DST_Status DS_DataStruct_Free ( void * Ptr, void * Data ) } /* Déverrouillage de la data structure si besoin */ - +/* if (Locked == TRUE) SM_Heap_Unlock (Heap); return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Routine d'affichage d'un message d'erreur */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Routine d'affichage d'un message d'erreur */ +/*----------------------------------------------------------------------------*/ +/* void DS_Error_Print ( void ) { if (DS_stderr) fprintf (DS_stderr, "%s\n", DS_Error_Msg); } -/*------------------------------------------------------------------------------*/ -/* Pour préfixer les noms de heap avec l'identifiant de la librairie */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Pour préfixer les noms de heap avec l'identifiant de la librairie */ +/*----------------------------------------------------------------------------*/ +/* static char * DS_Name_Prefix ( const char * Name ) { static char Prefixed [256]; @@ -2937,16 +3062,17 @@ static char * DS_Name_Prefix ( const char * Name ) return Prefixed; } -/*------------------------------------------------------------------------------*/ -/* Création d'un sémaphore pour gérer l'ouverture d'une data structure */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Création d'un sémaphore pour gérer l'ouverture d'une data structure */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Semaphore_Create ( NDT_Root * Root ) { union semun Sem_Ctl; DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User); /* Création du sémaphore */ - +/* RootDesc->OpenSemID = semget (IPC_PRIVATE, 1, 0777|IPC_CREAT|IPC_EXCL); if (RootDesc->OpenSemID == -1) { @@ -2971,7 +3097,7 @@ DST_Status DS_Semaphore_Create ( NDT_Root * Root ) } /* Initialisation du sémaphore à 0 */ - +/* Sem_Ctl.val = 0; if (semctl (RootDesc->OpenSemID, 0, SETVAL, Sem_Ctl)) { @@ -2986,9 +3112,10 @@ DST_Status DS_Semaphore_Create ( NDT_Root * Root ) return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Opération sur un sémaphore */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Opération sur un sémaphore */ +/*----------------------------------------------------------------------------*/ +/* DST_Status DS_Semaphore_Operate (int SemID, struct sembuf * Operations, unsigned int Nb_Oper) { if (semop (SemID, Operations, Nb_Oper) == -1) @@ -3036,9 +3163,10 @@ DST_Status DS_Semaphore_Operate (int SemID, struct sembuf * Operations, unsigned return DSS_OK; } -/*------------------------------------------------------------------------------*/ -/* Fonction manager de la liste des DS ouvertes */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fonction manager de la liste des DS ouvertes */ +/*----------------------------------------------------------------------------*/ +/* NDT_Status DS_OpenedDS_List_Manager ( va_list Args ) { NDT_Command Command = (NDT_Command) va_arg (Args, NDT_Command); diff --git a/lib/libdatastr.h b/lib/libdatastr.h index d27094a..7c0e6e4 100644 --- a/lib/libdatastr.h +++ b/lib/libdatastr.h @@ -1,3 +1,31 @@ +/*----------------------------------------------------------------------------*/ +/* libdatastr.h */ +/*----------------------------------------------------------------------------*/ + +/*----------------------------------------------------------------------------*/ +/* This file is part of LibDataStr. */ +/* */ +/* LibDataStr 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. */ +/* */ +/* LibDataStr 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 LibDataStr. If not, see */ +/* . */ +/*----------------------------------------------------------------------------*/ + + + +/*----------------------------------------------------------------------------*/ +/* Includes */ +/*----------------------------------------------------------------------------*/ + #include #include #include @@ -7,7 +35,9 @@ #include #include #include -#include + +//#include + #include #include @@ -50,48 +80,48 @@ typedef struct { char * Name; } DST_DataStruct; -/*------------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* Fonctions privées de la librairie */ -/*------------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fonctions privées de la librairie */ +/*----------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ -/*------------------------------------------------------------------------------*/ -/* Création d'un sémaphore pour gérer l'ouverture d'une data structure */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Création d'un sémaphore pour gérer l'ouverture d'une data structure */ +/*----------------------------------------------------------------------------*/ DST_Status DS_Semaphore_Create (NDT_Root * Root); -/*------------------------------------------------------------------------------*/ -/* Opération sur un sémaphore */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Opération sur un sémaphore */ +/*----------------------------------------------------------------------------*/ DST_Status DS_Semaphore_Operate (int, struct sembuf *, unsigned int); -/*------------------------------------------------------------------------------*/ -/* Fonction d'allocation attachée à une structure de données : */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fonction d'allocation attachée à une structure de données : */ +/*----------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Alloc ( size_t Size, void ** Ptr, void * Data ); -/*------------------------------------------------------------------------------*/ -/* Fonction de désallocation attachée à une structure de données : */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fonction de désallocation attachée à une structure de données : */ +/*----------------------------------------------------------------------------*/ DST_Status DS_DataStruct_Free ( void * Ptr, void * Data ); -/*------------------------------------------------------------------------------*/ -/* Routine d'affichage d'un message d'erreur */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Routine d'affichage d'un message d'erreur */ +/*----------------------------------------------------------------------------*/ void DS_Error_Print ( void ); -/*------------------------------------------------------------------------------*/ -/* Pour préfixer les noms de heap avec l'identifiant de la librairie */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Pour préfixer les noms de heap avec l'identifiant de la librairie */ +/*----------------------------------------------------------------------------*/ static char * DS_Name_Prefix (const char * Name); -/*------------------------------------------------------------------------------*/ -/* Teste si une data structure a déjà été ouverte par le processus courant */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Teste si une data structure a déjà été ouverte par le processus courant */ +/*----------------------------------------------------------------------------*/ DST_Status DS_DataStruct_IsOpen (const char * DS_Name, NDT_Root ** Root); -/*------------------------------------------------------------------------------*/ -/* Fonction manager de la liste des DS ouvertes */ -/*------------------------------------------------------------------------------*/ +/*----------------------------------------------------------------------------*/ +/* Fonction manager de la liste des DS ouvertes */ +/*----------------------------------------------------------------------------*/ NDT_Status DS_OpenedDS_List_Manager (va_list Args); diff --git a/util/Makefile b/util/Makefile index e0b4152..ff5958e 100644 --- a/util/Makefile +++ b/util/Makefile @@ -11,12 +11,12 @@ include ../Makefile.rule -DEP_STATIC += ../lib/libnode.a ../../liblog/lib/liblog.a -DEP_DYNAMIC += ../lib/libnode.so ../../liblog/lib/liblog.so -INCLUDE += -I . -I ../include -I ../../liblog/include -LIBDIR += -L . -L ../lib -L ../../liblog/lib -LIB_STATIC += ../lib/libnode.a ../../liblog/lib/liblog.a -ldl -LIB_DYNAMIC += -lnode -llog -ldl +DEP_STATIC += ../lib/libdatastr.a ../../libshmem/lib/libshmem.a ../../libnode/lib/libnode.a ../../liblog/lib/liblog.a +DEP_DYNAMIC += ../lib/libdatastr.so ../lib/libnode.so ../../liblog/lib/liblog.so +INCLUDE += -I . -I ../include -I ../../liblog/include -I ../../libnode/include -I ../../libshmem/include +LIBDIR += -L . -L ../lib -L ../../liblog/lib -L ../../libnode/lib -L ../../libshmem/lib +LIB_STATIC += ../lib/libdatastr.a ../../libshmem/lib/libshmem.a ../../libnode/lib/libnode.a ../../liblog/lib/liblog.a -ldl +LIB_DYNAMIC += -ldatastr -lshmem -lnode -llog -ldl CFLAGS += -rdynamic ifdef _LIBVER_SUPPORT