- Implement Open, Close, Info, Lock & Unlock default handlers,
- Implement Open, Close, Info, Lock & Unlock exec function handlers, - Add Init & Open handler calls in ND_DataStruct_Open(), - Add Info handler call in ND_DataStruct_Info_Print_I(), - Update ND_Node_Root_Alloc().
This commit is contained in:
672
lib/libnode.c
672
lib/libnode.c
@@ -973,11 +973,12 @@ NDT_Status ND_Index_Open_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_I
|
||||
// NDT_Allocator_Name Allocator_Name, NDT_Allocator *Allocator_Ptr, NDT_Deallocator_Name Deallocator_Name, NDT_Deallocator *Deallocator_Ptr, short Own_Value, void *Data)
|
||||
|
||||
NDT_Status ND_DataStruct_Open_I( NDT_Root **Root_Ptr_Ptr, NDT_DataStruct_Name Name, NDT_Index_Nb Index_Nb, NDT_Index_Type *Type_Ptr, NDT_Manager_Name Manager_Name, NDT_Manager *Manager_Ptr,
|
||||
NDT_Handler *Handler_Tab, short Own_Value, void *Data_Ptr)
|
||||
NDT_Handler *Handler_Tab, short Own_Value, void *User_Ptr)
|
||||
{
|
||||
NDT_Status status;
|
||||
NDT_Handler handler_target_tab[ NDD_HANDLER_NB];
|
||||
NDT_Handler_Id handler_id;
|
||||
size_t root_extra_size;
|
||||
|
||||
|
||||
if( Handler_Tab == NULL)
|
||||
@@ -993,26 +994,24 @@ NDT_Status ND_DataStruct_Open_I( NDT_Root **Root_Ptr_Ptr, NDT_DataStruct_Name
|
||||
if( Manager_Name != NULL)
|
||||
{
|
||||
NDD_HANDLER_SET( handler_target_tab[ NDD_HANDLER_ID_MANAGER], Manager_Name, Manager_Ptr);
|
||||
|
||||
// ND_STRCPY( handlers_target.Manager_Name, Manager_Name, NDD_HANDLER_NAME_SIZE);
|
||||
// handlers_target.Manager_Ptr = Manager_Ptr;
|
||||
|
||||
// ND_Handler_Set( handlers_target, NDD_HANDLER_MANAGER, Manager_Name, Manager_Ptr);
|
||||
}
|
||||
else
|
||||
{
|
||||
if( Manager_Ptr != NULL)
|
||||
{
|
||||
NDD_HANDLER_SET( handler_target_tab[ NDD_HANDLER_ID_MANAGER], "", Manager_Ptr);
|
||||
|
||||
// ND_STRCPY( handlers_target.Manager_Name, "", NDD_HANDLER_NAME_SIZE);
|
||||
// handlers_target.Manager_Ptr = Manager_Ptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Call init function */
|
||||
|
||||
if( ( status = ND_Handler_Init_Exec_I( &root_extra_size, handler_target_tab, handler_target_tab[ NDD_HANDLER_ID_INIT].Name, ( NDT_Handler_Init *)handler_target_tab[ NDD_HANDLER_ID_INIT].Ptr, User_Ptr)) != NDS_OK)
|
||||
{
|
||||
return( status);
|
||||
}
|
||||
|
||||
|
||||
/* Complete with default handlers */
|
||||
|
||||
for( handler_id = 0; handler_id < NDD_HANDLER_ID_NB; handler_id++)
|
||||
@@ -1023,43 +1022,22 @@ NDT_Status ND_DataStruct_Open_I( NDT_Root **Root_Ptr_Ptr, NDT_DataStruct_Name
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
NDG_Handler_Tab_Default[ handler_id]
|
||||
if( ( strlen( handlers_target.Manager_Name) == 0) && ( handlers_target.Manager_Ptr == NULL))
|
||||
|
||||
|
||||
if( ( status = ND_Node_Root_Alloc( Root_Ptr_Ptr, Name, Index_Nb, Type_Ptr, handler_target_tab, root_extra_size, Own_Value, User_Ptr)) != NDS_OK)
|
||||
{
|
||||
|
||||
// ND_STRCPY( handlers_target.Manager_Name, "ND_Default_Manager", NDD_HANDLER_NAME_SIZE);
|
||||
// handlers_target.Manager_Ptr = ND_Default_Manager;
|
||||
|
||||
|
||||
ND_STRCPY( handler_tab_target[ NDD_HANDLER_ID_MANAGER].Name, "ND_Default_Manager", NDD_HANDLER_NAME_SIZE);
|
||||
handler_tab_target[NDD_HANDLER_ID_MANAGER].Ptr = ND_Default_Manager;
|
||||
|
||||
NDD_HANDLER_SET( handler_tab_target[ NDD_HANDLER_ID_MANAGER], "ND_Default_Manager", ND_Default_Manager);
|
||||
|
||||
ND_Handler_Set( &handlers_target, NDD_HANDLER_MANAGER, "ND_Default_Manager", ND_Default_Manager);
|
||||
return( status);
|
||||
}
|
||||
|
||||
|
||||
if( ( strlen( handlers_target.Alloc_Name) == 0) && ( handlers_target.Alloc_Ptr == NULL))
|
||||
/* Call init function */
|
||||
|
||||
if( ( status = ND_Handler_Open_Exec_I( *Root_Ptr_Ptr, 0, handler_target_tab[ NDD_HANDLER_ID_OPEN].Name, ( NDT_Handler_Open *)handler_target_tab[ NDD_HANDLER_ID_OPEN].Ptr, User_Ptr)) != NDS_OK)
|
||||
{
|
||||
ND_STRCPY( handlers_target.Alloc_Name, "ND_Default_Allocator", NDD_HANDLER_NAME_SIZE);
|
||||
handlers_target.Alloc_Ptr = ND_Default_Allocator;
|
||||
return( status);
|
||||
}
|
||||
|
||||
if( ( strlen( handlers_target.Free_Name) == 0) && ( handlers_target.Free_Ptr == NULL))
|
||||
{
|
||||
ND_STRCPY( handlers_target.Free_Name, "ND_Default_Deallocator", NDD_HANDLER_NAME_SIZE);
|
||||
handlers_target.Free_Ptr = ND_Default_Deallocator;
|
||||
}
|
||||
|
||||
*/
|
||||
// status = ND_Node_Root_Alloc( Root_Ptr_Ptr, Index_Nb, Type_Ptr, Real_Manager_Name, Real_Manager_Ptr, Real_Allocator_Name, Real_Allocator_Ptr, Real_Deallocator_Name, Real_Deallocator_Ptr, Own_Value, Data);
|
||||
|
||||
status = ND_Node_Root_Alloc( Root_Ptr_Ptr, Name, Index_Nb, Type_Ptr, handler_target_tab, Own_Value, Data_Ptr);
|
||||
|
||||
if( ND_ERROR( status)) return( status);
|
||||
|
||||
return( NDS_OK);
|
||||
return( NDS_OK);
|
||||
}
|
||||
|
||||
|
||||
@@ -2153,10 +2131,12 @@ NDT_Status ND_DataStruct_Info_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Recu
|
||||
if( ND_RECURSIVE_PARENT_IS( Recursive_Mode))
|
||||
{
|
||||
memset( offset, ' ', Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET);
|
||||
offset[Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET] = '\0';
|
||||
offset[ Recursive_Offset * ND_RECURSIVE_PRINT_OFFSET] = '\0';
|
||||
|
||||
status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_MANAGER_VERSION, &version_name);
|
||||
if( ND_ERROR( status)) return( status);
|
||||
if( ( status = ND_Manager_Exec_I( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_MANAGER_VERSION, &version_name)) != NDS_OK)
|
||||
{
|
||||
return( status);
|
||||
}
|
||||
/*
|
||||
fprintf( Out, "%sRoot: (%s%p)\tIndex Nb: (%d)\tIndex Open Count: (%d)\tManager: (%s%p) [%s]\n%sAllocator: (%s%p) [%s]\tDeallocator: (%s%p) [%s]\tUser: (%s%p)\n%sManager Version: [%s]\n\n",
|
||||
offset, NDD_PRINTF_PTR_PREFIX, Root_Ptr, Root_Ptr->Index_Nb, Root_Ptr->Index_Open_Count, NDD_PRINTF_PTR_PREFIX, Root_Ptr->Manager_Ptr, Root_Ptr->Manager_Name,
|
||||
@@ -2164,8 +2144,8 @@ NDT_Status ND_DataStruct_Info_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Recu
|
||||
offset, version_name);
|
||||
*/
|
||||
|
||||
LG_LOG_INFO_6( "%sRoot: (%s%p)\tName: [%s]\tIndex Nb: (%d)\tIndex Open Count: (%d)",
|
||||
offset, NDD_PRINTF_PTR_PREFIX, Root_Ptr, Root_Ptr->Name, Root_Ptr->Index_Nb, Root_Ptr->Index_Open_Count);
|
||||
LG_LOG_INFO_7( "%sRoot: (%s%p)\tName: [%s]\tIndex Nb: (%d)\tIndex Open Count: (%d)\tRoot_Size: (%ld)",
|
||||
offset, NDD_PRINTF_PTR_PREFIX, Root_Ptr, Root_Ptr->Name, Root_Ptr->Index_Nb, Root_Ptr->Index_Open_Count, Root_Ptr->Root_Size);
|
||||
|
||||
LG_LOG_INFO_13( "%sManager: (%s%p) [%s]\tInit: (%s%p) [%s]\tAlloc: (%s%p) [%s]\tFree: (%s%p) [%s]", offset,
|
||||
NDD_PRINTF_PTR_PREFIX, Root_Ptr->Handler_Tab[ NDD_HANDLER_ID_MANAGER].Ptr, Root_Ptr->Handler_Tab[ NDD_HANDLER_ID_MANAGER].Name,
|
||||
@@ -2182,6 +2162,11 @@ NDT_Status ND_DataStruct_Info_Print_I( FILE *Out, NDT_Root *Root_Ptr, NDT_Recu
|
||||
LG_LOG_INFO_4( "%sUser: (%s%p)\tManager Version: [%s]",
|
||||
offset, NDD_PRINTF_PTR_PREFIX, Root_Ptr->User_Ptr, version_name);
|
||||
|
||||
if( ( status = ND_Handler_Info_Exec_I( Root_Ptr, Recursive_Offset, Root_Ptr->Handler_Tab[ NDD_HANDLER_ID_INFO].Name, ( NDT_Handler_Info *)Root_Ptr->Handler_Tab[ NDD_HANDLER_ID_INFO].Ptr)) != NDS_OK)
|
||||
{
|
||||
return( status);
|
||||
}
|
||||
|
||||
LG_LOG_INFO_0( "");
|
||||
}
|
||||
|
||||
@@ -3639,50 +3624,399 @@ NDT_Status ND_Manager_Exec_C( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Initialize an handlers struture to default value */
|
||||
/* Execute an init handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Handlers_Ptr: Handlers pointer to be initialized */
|
||||
/* (O) Root_Extra_Size: Pointer on the extra root size */
|
||||
/* (I) Handler_Tab: Pointer on the handler tab */
|
||||
/* (I) Handler_Init_Name: Init handler function name */
|
||||
/* (I) Handler_Init_Ptr: Init handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handlers_Init_I( NDT_Handler *Handler_Tab)
|
||||
NDT_Status ND_Handler_Init_Exec_I( size_t *Root_Extra_Size, NDT_Handler *Handler_Tab, NDT_Handler_Name Handler_Init_Name, NDT_Handler_Init *Handler_Init_Ptr, void *User_Ptr)
|
||||
{
|
||||
}
|
||||
NDT_Handler_Init *handler_init_ptr;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute an allocator function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (O) Value_Ptr_Ptr: Value pointer address */
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Size: Allocation size */
|
||||
/* (I) Allocator_Name: Value allocator function name */
|
||||
/* (I) Allocator_Ptr: Value allocator function pointer */
|
||||
/* (I) Data_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Init_Exec_I( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size, NDT_Allocator_Name Allocator_Name, NDT_Allocator *Allocator_Ptr, void *Data_Ptr)
|
||||
{
|
||||
NDT_Allocator *allocator_ptr;
|
||||
|
||||
|
||||
if( Allocator_Ptr != NULL)
|
||||
if( Handler_Init_Ptr != NULL)
|
||||
{
|
||||
allocator_ptr = Allocator_Ptr;
|
||||
handler_init_ptr = Handler_Init_Ptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( ND_Symbol_Find( (void **)&allocator_ptr, Allocator_Name) != NDS_OK)
|
||||
if( ND_Symbol_Find( (void **)&handler_init_ptr, Handler_Init_Name) != NDS_OK)
|
||||
{
|
||||
LG_LOG_ERROR_0( "Cant't find allocator function");
|
||||
LG_LOG_ERROR_0( "Cant't find init handler function");
|
||||
|
||||
return( NDS_KO);
|
||||
}
|
||||
}
|
||||
|
||||
return( allocator_ptr( Ptr_Ptr, Root_Ptr, Size, Data_Ptr));
|
||||
return( handler_init_ptr( Root_Extra_Size, Handler_Tab, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute an init handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (O) Root_Extra_Size: Pointer on the extra root size */
|
||||
/* (I) Handler_Tab: Pointer on the handler tab */
|
||||
/* (I) Handler_Init_Name: Init handler function name */
|
||||
/* (I) Handler_Init_Ptr: Init handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Init_Exec_C( size_t *Root_Extra_Size, NDT_Handler *Handler_Tab, NDT_Handler_Name Handler_Init_Name, NDT_Handler_Init *Handler_Init_Ptr, void *User_Ptr)
|
||||
{
|
||||
ND_LIBNODE_OPEN_CHECK();
|
||||
|
||||
ND_HANDLER_NOT_NULL_CHECK( Handler_Init_Name, Handler_Init_Ptr);
|
||||
|
||||
return( ND_Handler_Init_Exec_I( Root_Extra_Size, Handler_Tab, Handler_Init_Name, Handler_Init_Ptr, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute an alloc handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (O) Memory_Ptr_Ptr: Memory pointer address */
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Size: Allocation size */
|
||||
/* (I) Handler_Alloc_Name: Alloc handler function name */
|
||||
/* (I) Handler_Alloc_Ptr: Alloc handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Alloc_Exec_I( void **Memory_Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size, NDT_Handler_Name Handler_Alloc_Name, NDT_Handler_Alloc *Handler_Alloc_Ptr, void *User_Ptr)
|
||||
{
|
||||
NDT_Handler_Alloc *handler_alloc_ptr;
|
||||
|
||||
|
||||
if( Handler_Alloc_Ptr != NULL)
|
||||
{
|
||||
handler_alloc_ptr = Handler_Alloc_Ptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( ND_Symbol_Find( (void **)&handler_alloc_ptr, Handler_Alloc_Name) != NDS_OK)
|
||||
{
|
||||
LG_LOG_ERROR_0( "Cant't find alloc handler function");
|
||||
|
||||
return( NDS_KO);
|
||||
}
|
||||
}
|
||||
|
||||
return( handler_alloc_ptr( Memory_Ptr_Ptr, Root_Ptr, Size, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute an alloc handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (O) Memory_Ptr_Ptr: Memory pointer address */
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Size: Allocation size */
|
||||
/* (I) Handler_Alloc_Name: Alloc handler function name */
|
||||
/* (I) Handler_Alloc_Ptr: Alloc handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Alloc_Exec_C( void **Memory_Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size, NDT_Handler_Name Handler_Alloc_Name, NDT_Handler_Alloc *Handler_Alloc_Ptr, void *User_Ptr)
|
||||
{
|
||||
ND_LIBNODE_OPEN_CHECK();
|
||||
|
||||
ND_HANDLER_NOT_NULL_CHECK( Handler_Alloc_Name, Handler_Alloc_Ptr);
|
||||
|
||||
return( ND_Handler_Alloc_Exec_I( Memory_Ptr_Ptr, Root_Ptr, Size, Handler_Alloc_Name, Handler_Alloc_Ptr, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute a free handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Memory_Ptr: Memory pointer */
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Handler_Free_Name: Free handler function name */
|
||||
/* (I) Handler_Free_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Free_Exec_I( void *Memory_Ptr, NDT_Root *Root_Ptr, NDT_Handler_Name Handler_Free_Name, NDT_Handler_Free *Handler_Free_Ptr, void *User_Ptr)
|
||||
{
|
||||
NDT_Handler_Free *handler_free_ptr;
|
||||
|
||||
|
||||
ND_HANDLER_SYMBOL_FIND( handler_free_ptr, Handler_Free_Name, Handler_Free_Ptr);
|
||||
|
||||
return( handler_free_ptr( Memory_Ptr, Root_Ptr, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute a free handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Memory_Ptr: Memory pointer */
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Handler_Free_Name: Free handler function name */
|
||||
/* (I) Handler_Free_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Free_Exec_C( void *Memory_Ptr, NDT_Root *Root_Ptr, NDT_Handler_Name Handler_Free_Name, NDT_Handler_Free *Handler_Free_Ptr, void *User_Ptr)
|
||||
{
|
||||
ND_LIBNODE_OPEN_CHECK();
|
||||
|
||||
ND_HANDLER_NOT_NULL_CHECK( Handler_Free_Name, Handler_Free_Ptr);
|
||||
|
||||
return( ND_Handler_Free_Exec_I( Memory_Ptr, Root_Ptr, Handler_Free_Name, Handler_Free_Ptr, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute an open handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Open_Mode: Open mode */
|
||||
/* (I) Handler_Open_Name: Free handler function name */
|
||||
/* (I) Handler_Open_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Open_Exec_I( NDT_Root *Root_Ptr, NDT_Open_Flag Open_Mode, NDT_Handler_Name Handler_Open_Name, NDT_Handler_Open *Handler_Open_Ptr, void *User_Ptr)
|
||||
{
|
||||
NDT_Handler_Open *handler_open_ptr;
|
||||
|
||||
|
||||
ND_HANDLER_SYMBOL_FIND( handler_open_ptr, Handler_Open_Name, Handler_Open_Ptr);
|
||||
|
||||
return( handler_open_ptr( Root_Ptr, Open_Mode, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute an open handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Open_Mode: Open mode */
|
||||
/* (I) Handler_Open_Name: Free handler function name */
|
||||
/* (I) Handler_Open_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Open_Exec_C( NDT_Root *Root_Ptr, NDT_Open_Flag Open_Mode, NDT_Handler_Name Handler_Open_Name, NDT_Handler_Open *Handler_Open_Ptr, void *User_Ptr)
|
||||
{
|
||||
ND_LIBNODE_OPEN_CHECK();
|
||||
|
||||
ND_HANDLER_NOT_NULL_CHECK( Handler_Open_Name, Handler_Open_Ptr);
|
||||
|
||||
return( ND_Handler_Open_Exec_I( Root_Ptr, Open_Mode, Handler_Open_Name, Handler_Open_Ptr, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute a close handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Close_Mode: Close mode */
|
||||
/* (I) Handler_Close_Name: Free handler function name */
|
||||
/* (I) Handler_Close_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Close_Exec_I( NDT_Root *Root_Ptr, NDT_Close_Flag Close_Mode, NDT_Handler_Name Handler_Close_Name, NDT_Handler_Close *Handler_Close_Ptr, void *User_Ptr)
|
||||
{
|
||||
NDT_Handler_Close *handler_close_ptr;
|
||||
|
||||
|
||||
ND_HANDLER_SYMBOL_FIND( handler_close_ptr, Handler_Close_Name, Handler_Close_Ptr);
|
||||
|
||||
return( handler_close_ptr( Root_Ptr, Close_Mode, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute a close handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Close_Mode: Close mode */
|
||||
/* (I) Handler_Close_Name: Free handler function name */
|
||||
/* (I) Handler_Close_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Close_Exec_C( NDT_Root *Root_Ptr, NDT_Close_Flag Close_Mode, NDT_Handler_Name Handler_Close_Name, NDT_Handler_Close *Handler_Close_Ptr, void *User_Ptr)
|
||||
{
|
||||
ND_LIBNODE_OPEN_CHECK();
|
||||
|
||||
ND_HANDLER_NOT_NULL_CHECK( Handler_Close_Name, Handler_Close_Ptr);
|
||||
|
||||
return( ND_Handler_Close_Exec_I( Root_Ptr, Close_Mode, Handler_Close_Name, Handler_Close_Ptr, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute an Info handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Recursive_Offset: Print line offset */
|
||||
/* (I) Handler_Info_Name: Free handler function name */
|
||||
/* (I) Handler_Info_Ptr: Free handler function pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Info_Exec_I( NDT_Root *Root_Ptr, NDT_Recursive_Offset Recursive_Offset, NDT_Handler_Name Handler_Info_Name, NDT_Handler_Info *Handler_Info_Ptr)
|
||||
{
|
||||
NDT_Handler_Info *handler_info_ptr;
|
||||
|
||||
|
||||
ND_HANDLER_SYMBOL_FIND( handler_info_ptr, Handler_Info_Name, Handler_Info_Ptr);
|
||||
|
||||
return( handler_info_ptr( Root_Ptr, Recursive_Offset));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute an Info handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Recursive_Offset: Print line offset */
|
||||
/* (I) Handler_Info_Name: Free handler function name */
|
||||
/* (I) Handler_Info_Ptr: Free handler function pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Info_Exec_C( NDT_Root *Root_Ptr, NDT_Recursive_Offset Recursive_Offset, NDT_Handler_Name Handler_Info_Name, NDT_Handler_Info *Handler_Info_Ptr)
|
||||
{
|
||||
ND_LIBNODE_OPEN_CHECK();
|
||||
|
||||
ND_HANDLER_NOT_NULL_CHECK( Handler_Info_Name, Handler_Info_Ptr);
|
||||
|
||||
return( ND_Handler_Info_Exec_I( Root_Ptr, Recursive_Offset, Handler_Info_Name, Handler_Info_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute a lock handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Open_Mode: Lock mode */
|
||||
/* (O) Locked_Ptr: Locked flag */
|
||||
/* (I) Handler_Lock_Name: Free handler function name */
|
||||
/* (I) Handler_Lock_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Lock_Exec_I( NDT_Root *Root_Ptr, NDT_Lock_Flag Lock_Mode, bool *Locked_Ptr, NDT_Handler_Name Handler_Lock_Name, NDT_Handler_Lock *Handler_Lock_Ptr, void *User_Ptr)
|
||||
{
|
||||
NDT_Handler_Lock *handler_lock_ptr;
|
||||
|
||||
|
||||
ND_HANDLER_SYMBOL_FIND( handler_lock_ptr, Handler_Lock_Name, Handler_Lock_Ptr);
|
||||
|
||||
return( handler_lock_ptr( Root_Ptr, Lock_Mode, Locked_Ptr, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute a lock handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Open_Mode: Lock mode */
|
||||
/* (O) Locked_Ptr: Locked flag */
|
||||
/* (I) Handler_Lock_Name: Free handler function name */
|
||||
/* (I) Handler_Lock_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Lock_Exec_C( NDT_Root *Root_Ptr, NDT_Lock_Flag Lock_Mode, bool *Locked_Ptr, NDT_Handler_Name Handler_Lock_Name, NDT_Handler_Lock *Handler_Lock_Ptr, void *User_Ptr)
|
||||
{
|
||||
ND_LIBNODE_OPEN_CHECK();
|
||||
|
||||
ND_HANDLER_NOT_NULL_CHECK( Handler_Lock_Name, Handler_Lock_Ptr);
|
||||
|
||||
return( ND_Handler_Lock_Exec_I( Root_Ptr, Lock_Mode, Locked_Ptr, Handler_Lock_Name, Handler_Lock_Ptr, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute an unlock handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Handler_Unlock_Name: Free handler function name */
|
||||
/* (I) Handler_Unlock_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Unlock_Exec_I( NDT_Root *Root_Ptr, NDT_Handler_Name Handler_Unlock_Name, NDT_Handler_Unlock *Handler_Unlock_Ptr, void *User_Ptr)
|
||||
{
|
||||
NDT_Handler_Unlock *handler_unlock_ptr;
|
||||
|
||||
|
||||
ND_HANDLER_SYMBOL_FIND( handler_unlock_ptr, Handler_Unlock_Name, Handler_Unlock_Ptr);
|
||||
|
||||
return( handler_unlock_ptr( Root_Ptr, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Execute an unlock handler function */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Handler_Unlock_Name: Free handler function name */
|
||||
/* (I) Handler_Unlock_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Unlock_Exec_C( NDT_Root *Root_Ptr, NDT_Handler_Name Handler_Unlock_Name, NDT_Handler_Unlock *Handler_Unlock_Ptr, void *User_Ptr)
|
||||
{
|
||||
ND_LIBNODE_OPEN_CHECK();
|
||||
|
||||
ND_HANDLER_NOT_NULL_CHECK( Handler_Unlock_Name, Handler_Unlock_Ptr);
|
||||
|
||||
return( ND_Handler_Unlock_Exec_I( Root_Ptr, Handler_Unlock_Name, Handler_Unlock_Ptr, User_Ptr));
|
||||
}
|
||||
|
||||
|
||||
@@ -3699,7 +4033,7 @@ NDT_Status ND_Handler_Init_Exec_I( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t
|
||||
/* (I) Allocator_Ptr: Value allocator function pointer */
|
||||
/* (I) Data_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/* to be deleted */
|
||||
NDT_Status ND_Allocator_Exec_I( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size, NDT_Allocator_Name Allocator_Name, NDT_Allocator *Allocator_Ptr, void *Data_Ptr)
|
||||
{
|
||||
NDT_Allocator *allocator_ptr;
|
||||
@@ -3736,17 +4070,12 @@ NDT_Status ND_Allocator_Exec_I( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t S
|
||||
/* (I) Allocator_Ptr: Value allocator function pointer */
|
||||
/* (I) Data_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/* to be deleted */
|
||||
NDT_Status ND_Allocator_Exec_C( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size, NDT_Allocator_Name Allocator_Name, NDT_Allocator *Allocator_Ptr, void *Data_Ptr)
|
||||
{
|
||||
ND_LIBNODE_OPEN_CHECK();
|
||||
|
||||
if( ( Allocator_Name == NULL) && ( Allocator_Ptr == NULL))
|
||||
{
|
||||
LG_LOG_ERROR_0( "Undefined function name");
|
||||
|
||||
return( NDS_ERRAPI);
|
||||
}
|
||||
ND_HANDLER_NOT_NULL_CHECK( Allocator_Name, Allocator_Ptr);
|
||||
|
||||
return( ND_Allocator_Exec_I( Ptr_Ptr, Root_Ptr, Size, Allocator_Name, Allocator_Ptr, Data_Ptr));
|
||||
}
|
||||
@@ -3764,7 +4093,7 @@ NDT_Status ND_Allocator_Exec_C( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t S
|
||||
/* (I) Allocator_Ptr: Value deallocator function pointer */
|
||||
/* (I) Data_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/* to be deleted */
|
||||
NDT_Status ND_Deallocator_Exec_I( void *Ptr, NDT_Root *Root_Ptr, NDT_Deallocator_Name Deallocator_Name, NDT_Deallocator *Deallocator_Ptr, void *Data_Ptr)
|
||||
{
|
||||
NDT_Deallocator *deallocator_ptr;
|
||||
@@ -3800,7 +4129,7 @@ NDT_Status ND_Deallocator_Exec_I( void *Ptr, NDT_Root *Root_Ptr, NDT_Deallocat
|
||||
/* (I) Allocator_Ptr: Value deallocator function pointer */
|
||||
/* (I) Data_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/* to be deleted */
|
||||
NDT_Status ND_Deallocator_Exec_C( void *Ptr, NDT_Root *Root_Ptr, NDT_Deallocator_Name Deallocator_Name, NDT_Deallocator *Deallocator_Ptr, void *Data_Ptr)
|
||||
{
|
||||
ND_LIBNODE_OPEN_CHECK();
|
||||
@@ -3827,6 +4156,164 @@ NDT_Status ND_Deallocator_Exec_C( void *Ptr, NDT_Root *Root_Ptr, NDT_Deallocat
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Init handler: */
|
||||
/* - Return extra root size */
|
||||
/* - Update handler tab */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (O) Root_Extra_Size: Pointer on the extra root size */
|
||||
/* (I) Handler_Tab: Pointer on the handler tab */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Init_Default( size_t *Root_Extra_Size, NDT_Handler *Handler_Tab, void *User_Ptr)
|
||||
{
|
||||
*Root_Extra_Size = 0L;
|
||||
|
||||
return( NDS_OK);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default alloc handler: */
|
||||
/* malloc() function wrapper with NDT_Status return status */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (O) Memory_Ptr_Ptr: Memory pointer address */
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Size: Allocation size */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Alloc_Default( void **Memory_Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size, void *User_Ptr)
|
||||
{
|
||||
*Memory_Ptr_Ptr = malloc( Size);
|
||||
|
||||
|
||||
if( !*Memory_Ptr_Ptr) return( NDS_ERRMEM);
|
||||
|
||||
return( NDS_OK);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default free handler: */
|
||||
/* free() function wrapper with NDT_Status return status */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Memory_Ptr: Memory pointer */
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Free_Default( void *Memory_Ptr, NDT_Root *Root_Ptr, void *User_Ptr)
|
||||
{
|
||||
if( !Memory_Ptr) return( NDS_ERRAPI);
|
||||
|
||||
free( Memory_Ptr);
|
||||
|
||||
return( NDS_OK);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default open handler */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Open_Mode: Open mode */
|
||||
/* (I) Handler_Open_Name: Free handler function name */
|
||||
/* (I) Handler_Open_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Open_Default( NDT_Root *Root_Ptr, NDT_Open_Flag Open_Mode, void *User_Ptr)
|
||||
{
|
||||
return( NDS_OK);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default close handler */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Close_Mode: Close mode */
|
||||
/* (I) Handler_Close_Name: Free handler function name */
|
||||
/* (I) Handler_Close_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Close_Default( NDT_Root *Root_Ptr, NDT_Close_Flag Close_Mode, void *User_Ptr)
|
||||
{
|
||||
return( NDS_OK);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default info handler */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Recursive_Offset: Print line offset */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Info_Default( NDT_Root *Root_Ptr, NDT_Recursive_Offset Recursive_Offset)
|
||||
{
|
||||
return( NDS_OK);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default lock handler */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Open_Mode: Lock mode */
|
||||
/* (O) Locked_Ptr: Locked flag */
|
||||
/* (I) Handler_Lock_Name: Free handler function name */
|
||||
/* (I) Handler_Lock_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Lock_Default( NDT_Root *Root_Ptr, NDT_Lock_Flag Lock_Mode, bool *Locked_Ptr, void *User_Ptr)
|
||||
{
|
||||
return( NDS_OK);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Defalt unlock handler */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Handler_Unlock_Name: Free handler function name */
|
||||
/* (I) Handler_Unlock_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Unlock_Default( NDT_Root *Root_Ptr, void *User_Ptr)
|
||||
{
|
||||
return( NDS_OK);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Symbol Lookup */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
@@ -3977,19 +4464,28 @@ NDT_Status ND_Index_Clear( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id)
|
||||
|
||||
// NDT_Status ND_Node_Root_Alloc( NDT_Root **Root_Ptr_Ptr, NDT_Index_Nb Index_Nb, NDT_Index_Type *Type_Ptr, char *Manager_Name, NDT_Manager *Manager_Ptr, char *Allocator_Name, NDT_Allocator *Allocator_Ptr, char *Deallocator_Name, NDT_Deallocator *Deallocator_Ptr, short Own_Value, void *Data_Ptr)
|
||||
|
||||
NDT_Status ND_Node_Root_Alloc( NDT_Root **Root_Ptr_Ptr, NDT_DataStruct_Name Name, NDT_Index_Nb Index_Nb, NDT_Index_Type *Type_Ptr, NDT_Handler *Handler_Tab, short Own_Value, void *Data_Ptr)
|
||||
NDT_Status ND_Node_Root_Alloc( NDT_Root **Root_Ptr_Ptr, NDT_DataStruct_Name Name, NDT_Index_Nb Index_Nb, NDT_Index_Type *Type_Ptr, NDT_Handler *Handler_Tab, size_t Root_Extra_Size, short Own_Value, void *User_Ptr)
|
||||
{
|
||||
NDT_Status status;
|
||||
size_t root_size;
|
||||
NDT_Index_Id index_id;
|
||||
|
||||
|
||||
status = ND_Allocator_Exec_I( (void **)Root_Ptr_Ptr, NULL, ( sizeof( NDT_Root) + sizeof(NDT_Index) * (Index_Nb - 1)), Handler_Tab[ NDD_HANDLER_ID_ALLOC].Name, (NDT_Allocator *)Handler_Tab[ NDD_HANDLER_ID_ALLOC].Ptr, Data_Ptr);
|
||||
if( ND_ERROR(status)) return( status);
|
||||
|
||||
root_size = sizeof( NDT_Root) + sizeof(NDT_Index) * (Index_Nb - 1) + Root_Extra_Size;
|
||||
|
||||
if( ( status = ND_Allocator_Exec_I( (void **)Root_Ptr_Ptr, NULL, root_size, Handler_Tab[ NDD_HANDLER_ID_ALLOC].Name, (NDT_Allocator *)Handler_Tab[ NDD_HANDLER_ID_ALLOC].Ptr, User_Ptr)) != NDS_OK)
|
||||
{
|
||||
return( status);
|
||||
}
|
||||
|
||||
|
||||
ND_STRCPY( ( *Root_Ptr_Ptr)->Name, Name, NDD_DATASTRUCT_NAME_SIZE);
|
||||
|
||||
( *Root_Ptr_Ptr)->Root_Size = root_size;
|
||||
|
||||
memcpy( &( ( *Root_Ptr_Ptr)->Handler_Tab), Handler_Tab, NDD_HANDLER_TAB_SIZE);
|
||||
|
||||
|
||||
/* To be removed... */
|
||||
ND_STRCPY( ( *Root_Ptr_Ptr)->Manager_Name, ( *Root_Ptr_Ptr)->Handler_Tab[ NDD_HANDLER_ID_MANAGER].Name, NDD_HANDLER_NAME_SIZE);
|
||||
( *Root_Ptr_Ptr)->Manager_Ptr = (NDT_Manager *)( *Root_Ptr_Ptr)->Handler_Tab[ NDD_HANDLER_ID_MANAGER].Ptr;
|
||||
@@ -4015,7 +4511,7 @@ NDT_Status ND_Node_Root_Alloc( NDT_Root **Root_Ptr_Ptr, NDT_DataStruct_Name Na
|
||||
*/
|
||||
|
||||
( *Root_Ptr_Ptr)->Own_Value = Own_Value;
|
||||
( *Root_Ptr_Ptr)->User_Ptr = Data_Ptr;
|
||||
( *Root_Ptr_Ptr)->User_Ptr = User_Ptr;
|
||||
|
||||
( *Root_Ptr_Ptr)->Index_Nb = Index_Nb;
|
||||
( *Root_Ptr_Ptr)->Index_Open_Count = 0;
|
||||
|
||||
214
lib/libnode.h
214
lib/libnode.h
@@ -119,41 +119,18 @@ NDT_Base NDG_Base =
|
||||
|
||||
|
||||
|
||||
//{
|
||||
// "", /* Default Manager function name */
|
||||
// NULL, /* Default Manager function pointer */
|
||||
// "", /* Default Init function name */
|
||||
// NULL, /* Default Init function pointer */
|
||||
//
|
||||
//// "ND_Default_Allocator", /* Default Alloc function name */
|
||||
//// ND_Default_Allocator, /* Default Alloc function pointer */
|
||||
//// "ND_Default_Deallocator", /* Default Free function name */
|
||||
//// ND_Default_Deallocator, /* Default Free function pointer */
|
||||
//
|
||||
// "", /* Default Alloc function name */
|
||||
// NULL, /* Default Alloc function pointer */
|
||||
// "", /* Default Free function name */
|
||||
// NULL, /* Default Free function pointer */
|
||||
// "", /* Default Open function name */
|
||||
// NULL, /* Default Open function pointer */
|
||||
// "", /* Default Close function name */
|
||||
// NULL, /* Default Close function pointer */
|
||||
// "", /* Default Lock function name */
|
||||
// NULL, /* Default Lock function pointer */
|
||||
// "", /* Default Unlock function name */
|
||||
// NULL /* Default Unlock function pointer */
|
||||
//};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
|
||||
#define ND_LIBNODE_OPEN_CHECK() if( NDG_Base.Open_Status != NDD_TRUE) { LG_LOG_ERROR_0( "LibNode library is not opened"); return( NDS_ERRAPI); }
|
||||
#define ND_NOT_NULL_CHECK( ptr, msg) if( !(ptr)) { LG_LOG_ERROR_1( "%s is null", (msg)); return( NDS_ERRAPI); }
|
||||
#define ND_LIBNODE_OPEN_CHECK() if( NDG_Base.Open_Status != NDD_TRUE) { LG_LOG_ERROR_0( "LibNode library is not opened"); return( NDS_ERRAPI); }
|
||||
#define ND_NOT_NULL_CHECK( Ptr, Msg) if( !( Ptr)) { LG_LOG_ERROR_1( "%s is null", ( Msg)); return( NDS_ERRAPI); }
|
||||
|
||||
#define ND_HANDLER_NOT_NULL_CHECK( Function_Name, Function_Ptr) if( ( !( Function_Name)) && ( !( Function_Ptr))) { LG_LOG_ERROR_0( "Undefined function name"); return( NDS_ERRAPI); }
|
||||
#define ND_HANDLER_SYMBOL_FIND( Function_Ptr, Handler_Name, Handler_Ptr) if( ( Handler_Ptr)) { ( Function_Ptr) = ( Handler_Ptr);} \
|
||||
else { if( ND_Symbol_Find( (void **)&( Function_Ptr), ( Handler_Name)) != NDS_OK) { LG_LOG_ERROR_0( "Cant't find free handler function"); return( NDS_KO);}}
|
||||
|
||||
|
||||
|
||||
@@ -225,12 +202,13 @@ NDT_Status ND_Index_Clear( NDT_Root *, NDT_Index_Id);
|
||||
/* (I) Index_Nb: Number of index */
|
||||
/* (I) Index_Type_Ptr: Array of Index type (List, tree, ...) */
|
||||
/* (I) Handlers_Ptr: Pointer to the data structure handlers */
|
||||
/* (I) Root_Extra_Size: Additional size to be allocated with root node */
|
||||
/* (I) Own_Value: Flag indicating if the structure is the node owner */
|
||||
/* (I) Data_Ptr: User pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
//NDT_Status ND_Node_Root_Alloc( NDT_Root **, NDT_Index_Nb, NDT_Index_Type[], char *, NDT_Manager *, char *, NDT_Allocator *, char *, NDT_Deallocator *, short, void *);
|
||||
|
||||
NDT_Status ND_Node_Root_Alloc( NDT_Root **Root_Ptr_Ptr, NDT_DataStruct_Name Name, NDT_Index_Nb Index_Nb, NDT_Index_Type *Type_Ptr, NDT_Handler *Handler_Tab, short Own_Value, void *Data_Ptr);
|
||||
NDT_Status ND_Node_Root_Alloc( NDT_Root **Root_Ptr_Ptr, NDT_DataStruct_Name Name, NDT_Index_Nb Index_Nb, NDT_Index_Type *Type_Ptr, NDT_Handler *Handler_Tab, size_t Root_Extra_Size, short Own_Value, void *User_Ptr);
|
||||
|
||||
|
||||
|
||||
@@ -350,41 +328,121 @@ NDT_Status ND_List_Sort( NDT_Root *, NDT_Index_Id);
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Post prototype global variable definitions */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Handler NDG_Handler_Tab_Default[ NDD_HANDLER_NB] =
|
||||
{
|
||||
{ "", /* Default Manager function name */
|
||||
NULL}, /* Default Manager function pointer */
|
||||
{ "", /* Default Init function name */
|
||||
NULL}, /* Default Init function pointer */
|
||||
|
||||
{ "ND_Default_Allocator", /* Default Alloc function name */
|
||||
(NDT_Handler_Function *)ND_Default_Allocator}, /* Default Alloc function pointer */
|
||||
{ "ND_Default_Deallocator", /* Default Free function name */
|
||||
(NDT_Handler_Function *)ND_Default_Deallocator}, /* Default Free function pointer */
|
||||
|
||||
// { "", /* Default Alloc function name */
|
||||
// NULL}, /* Default Alloc function pointer */
|
||||
// { "", /* Default Free function name */
|
||||
// NULL}, /* Default Free function pointer */
|
||||
{ "", /* Default Open function name */
|
||||
NULL}, /* Default Open function pointer */
|
||||
{ "", /* Default Close function name */
|
||||
NULL}, /* Default Close function pointer */
|
||||
{ "", /* Default Lock function name */
|
||||
NULL}, /* Default Lock function pointer */
|
||||
{ "", /* Default Unlock function name */
|
||||
NULL} /* Default Unlock function pointer */
|
||||
};
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* PRIVATE FUNCTIONS */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Init handler: */
|
||||
/* - Return extra root size */
|
||||
/* - Update handler tab */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (O) Root_Extra_Size: Pointer on the extra root size */
|
||||
/* (I) Handler_Tab: Pointer on the handler tab */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Init_Default( size_t *Root_Extra_Size, NDT_Handler *Handler_Tab, void *User_Ptr);
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default alloc handler: */
|
||||
/* malloc() function wrapper with NDT_Status return status */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (O) Memory_Ptr_Ptr: Memory pointer address */
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Size: Allocation size */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Alloc_Default( void **Memory_Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size, void *User_Ptr);
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default free handler: */
|
||||
/* free() function wrapper with NDT_Status return status */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Memory_Ptr: Memory pointer */
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Free_Default( void *Memory_Ptr, NDT_Root *Root_Ptr, void *User_Ptr);
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default open handler */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Open_Mode: Open mode */
|
||||
/* (I) Handler_Open_Name: Free handler function name */
|
||||
/* (I) Handler_Open_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Open_Default( NDT_Root *Root_Ptr, NDT_Open_Flag Open_Mode, void *User_Ptr);
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default close handler */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Close_Mode: Close mode */
|
||||
/* (I) Handler_Close_Name: Free handler function name */
|
||||
/* (I) Handler_Close_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Close_Default( NDT_Root *Root_Ptr, NDT_Close_Flag Close_Mode, void *User_Ptr);
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default info handler */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Recursive_Offset: Print line offset */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Info_Default( NDT_Root *Root_Ptr, NDT_Recursive_Offset Recursive_Offset);
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Default lock handler */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Open_Mode: Lock mode */
|
||||
/* (O) Locked_Ptr: Locked flag */
|
||||
/* (I) Handler_Lock_Name: Free handler function name */
|
||||
/* (I) Handler_Lock_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Lock_Default( NDT_Root *Root_Ptr, NDT_Lock_Flag Lock_Mode, bool *Locked_Ptr, void *User_Ptr);
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Defalt unlock handler */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* (I) Root_Ptr: Data structure pointer */
|
||||
/* (I) Handler_Unlock_Name: Free handler function name */
|
||||
/* (I) Handler_Unlock_Ptr: Free handler function pointer */
|
||||
/* (I) User_Ptr: User pointer */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Status ND_Handler_Unlock_Default( NDT_Root *Root_Ptr, void *User_Ptr);
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
void ND_List_Check( NDT_Root *, NDT_Index_Id, int *, int *, FILE *);
|
||||
@@ -422,3 +480,35 @@ NDT_Status ND_Symbol_Find( void **, const char *);
|
||||
void ND_Signal_Trap( int);
|
||||
|
||||
NDT_Status ND_Address_Check( void *);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*----------------------------------------------------------------------------*/
|
||||
/* Post prototype global variable definitions */
|
||||
/*----------------------------------------------------------------------------*/
|
||||
|
||||
NDT_Handler NDG_Handler_Tab_Default[ NDD_HANDLER_NB] =
|
||||
{
|
||||
{ "", /* Default Manager function name */
|
||||
NULL}, /* Default Manager function pointer */
|
||||
{ "ND_Handler_Init_Default", /* Default Init function name */
|
||||
( NDT_Handler_Function *)ND_Handler_Init_Default}, /* Default Init function pointer */
|
||||
{ "ND_Handler_Alloc_Default", /* Default Alloc function name */
|
||||
( NDT_Handler_Function *)ND_Handler_Alloc_Default}, /* Default Alloc function pointer */
|
||||
{ "ND_Handler_Free_Default", /* Default Free function name */
|
||||
( NDT_Handler_Function *)ND_Handler_Free_Default}, /* Default Free function pointer */
|
||||
{ "NDT_Handler_Open_Default", /* Default Open function name */
|
||||
( NDT_Handler_Function *)ND_Handler_Open_Default}, /* Default Open function pointer */
|
||||
{ "NDT_Handler_Close_Default", /* Default Close function name */
|
||||
( NDT_Handler_Function *)ND_Handler_Close_Default}, /* Default Close function pointer */
|
||||
{ "NDT_Handler_Info_Default", /* Default Lock function name */
|
||||
( NDT_Handler_Function *)ND_Handler_Info_Default}, /* Default Lock function pointer */
|
||||
{ "NDT_Handler_Lock_Default", /* Default Lock function name */
|
||||
( NDT_Handler_Function *)ND_Handler_Lock_Default}, /* Default Lock function pointer */
|
||||
{ "NDT_Handler_Unlock_Default", /* Default Unlock function name */
|
||||
( NDT_Handler_Function *)ND_Handler_Unlock_Default} /* Default Unlock function pointer */
|
||||
};
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user