Rx3/drummer
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
1218622bc6
drummer/drummer.c

1627 lines
44 KiB
C
Raw Normal View History

Initial commit: - Kit and Instrument data structure - Kit and Instrument XML loading - No layer support! - No GFX and no Sound!
2022-03-20 23:46:24 +01:00
/*---------------------------------------------------------------------------------*/
/* Includes */
/*---------------------------------------------------------------------------------*/
#define _IMRD_C_
#include <drummer.h>
/*---------------------------------------------------------------------------------*/
/* */
/*---------------------------------------------------------------------------------*/
NDT_Status DR_Instrument_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr)
{
NDT_Command_Name Command_Name;
switch( Command)
{
case NDD_CMD_MANAGER_VERSION:
{
ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *);
Command_Name = "NDD_CMD_MANAGER_VERSION";
*Version_Name_Ptr = "$Revision: 1.0 $ $Name: Instrument_Manager $ $Date: 2021/12/12 21:27:12 $ $Author: agibert $";
return( NDS_OK);
}
case NDD_CMD_INDEX_GET:
{
/*
ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *);
ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *);
ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command);
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
*/
ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *);
ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *);
ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command);
ND_VA_ARG_GET( Instrument_Ptr, *Args_Ptr, DRT_Instrument *);
Command_Name = "NDD_CMD_INDEX_GET";
switch(Cmd)
{
/*
case NDT_CMD_SOME_USER_CMD:
{
*Reply_Index_Id_Ptr = 0;
*Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD;
break;
}
...
*/
case NDD_CMD_INDEX0_PRINT:
{
*Reply_Index_Id_Ptr = 0;
*Reply_Command_Ptr = Cmd;
break;
}
case NDD_CMD_INDEX1_PRINT:
{
*Reply_Index_Id_Ptr = 1;
*Reply_Command_Ptr = Cmd;
break;
}
default:
{
*Reply_Index_Id_Ptr = Index_Id;
*Reply_Command_Ptr = Cmd;
break;
}
}
return( NDS_OK);
}
case NDD_CMD_VALUE_ALLOC:
{
/*
ND_VA_ARG_GET( Value_Ptr_Ptr, *Args_Ptr, void **);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Instrument_Ptr_Ptr, *Args_Ptr, DRT_Instrument **);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( Name, user_args, char *);
ND_VA_ARG_GET( FileName, user_args, char *);
ND_VA_ARG_GET( Gain, user_args, double);
ND_VA_ARG_GET( Sample_Ptr, user_args, char *);
ND_VA_ARG_GET( Sample_Size, user_args, long);
ND_VA_LIST_CLOSE( user_args);
Command_Name = "NDD_CMD_VALUE_ALLOC";
if( ( *Instrument_Ptr_Ptr = (DRT_Instrument *)malloc( sizeof( DRT_Instrument))) != NULL)
{
( *Instrument_Ptr_Ptr)->Id = Root_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number;
strncpy( ( *Instrument_Ptr_Ptr)->Name, Name, NAME_LEN);
strncpy( ( *Instrument_Ptr_Ptr)->FileName, FileName, FILENAME_LEN);
(*Instrument_Ptr_Ptr)->Name[ NAME_LEN] = '\0';
(*Instrument_Ptr_Ptr)->FileName[FILENAME_LEN] = '\0';
( *Instrument_Ptr_Ptr)->Gain = Gain;
( *Instrument_Ptr_Ptr)->Sample_Ptr = Sample_Ptr;
( *Instrument_Ptr_Ptr)->Sample_Size = Sample_Size;
return( NDS_OK);
}
else
{
return( NDS_KO);
}
}
case NDD_CMD_VALUE_FREE:
{
/*
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Instrument_Ptr, *Args_Ptr, DRT_Instrument *);
Command_Name = "NDD_CMD_VALUE_FREE";
free( Instrument_Ptr);
return( NDS_OK);
}
case NDD_CMD_VALUE_COMP:
{
/*
ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, void *);
ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Instrument1_Ptr, *Args_Ptr, DRT_Instrument *);
ND_VA_ARG_GET( Instrument2_Ptr, *Args_Ptr, DRT_Instrument *);
long rc;
Command_Name = "NDD_CMD_VALUE_COMP";
switch( Index_Id)
{
case 0:
{
rc = Instrument1_Ptr->Id - Instrument2_Ptr->Id;
break;
}
case 1:
{
rc = strcmp( Instrument1_Ptr->Name, Instrument2_Ptr->Name);
break;
}
default:
{
printf( "Unknown COMP idx (%d) !\n", Index_Id);
return( NDS_KO);
}
}
if( rc < 0)
{
return( NDS_LOWER);
}
else
{
if( rc > 0)
{
return( NDS_GREATER);
}
else
{
return( NDS_EQUAL);
}
}
}
case NDD_CMD_VALUE_ADD:
{
/*
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
Command_Name = "NDD_CMD_VALUE_ADD";
return( NDS_OK);
}
case NDD_CMD_VALUE_REMOVE:
{
/*
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
Command_Name = "NDD_CMD_VALUE_REMOVE";
return( NDS_OK);
}
case NDD_CMD_VALUE_PRINT:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
ND_VA_LIST_OPEN( user_args, lib_args);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
ND_VA_LIST_CLOSE( lib_args);
void *Value_Ptr = Node_Ptr->Value;
*/
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
ND_VA_LIST_OPEN( user_args, lib_args);
ND_VA_ARG_GET( Count_Ptr, user_args, long *);
ND_VA_LIST_CLOSE( user_args);
ND_VA_LIST_CLOSE( lib_args);
DRT_Instrument *Instrument_Ptr = Node_Ptr->Value;
Command_Name = "NDD_CMD_VALUE_PRINT";
if( DR_Instrument_Dump( Instrument_Ptr, ++(*Count_Ptr)) != DRS_OK)
{
return( NDS_KO);
}
else
{
return( NDS_OK);
}
}
case NDD_CMD_INFO_PRINT:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
ND_VA_LIST_OPEN( user_args, lib_args);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
ND_VA_LIST_CLOSE( lib_args);
*/
Command_Name = "NDD_CMD_INFO_PRINT";
return( NDS_OK);
}
case NDD_CMD_INDEX0_PRINT:
case NDD_CMD_INDEX1_PRINT:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( Out, user_args, FILE *);
ND_VA_ARG_GET( Count_Ptr, user_args, long *);
ND_VA_LIST_CLOSE( user_args);
DRT_Instrument *Instrument_Ptr = Node_Ptr->Value;
Command_Name = "NDD_CMD_INDEX_PRINT";
if( DR_Instrument_Dump( Instrument_Ptr, ++(*Count_Ptr)) != DRS_OK)
{
return( NDS_KO);
}
else
{
return( NDS_OK);
}
}
/*
case NDD_CMD_PHONEBOOK_SAVE:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( Out, user_args, FILE *);
ND_VA_ARG_GET( Count_Ptr, user_args, long *);
ND_VA_LIST_CLOSE( user_args);
DRT_Instrument *Instrument_Ptr = Node_Ptr->Value;
Command_Name = "NDD_CMD_PHONEBOOK_SAVE";
fprintf( Out, "%s:%s:%s:%s\n", Instrument_Ptr->Number, Instrument_Ptr->Name, Instrument_Ptr->Address, Instrument_Ptr->Email);
(*Count_Ptr)++;
return( NDS_OK);
}
*/
default:
{
printf( "Instrument_Manager() called with an undefined command %d\n", Command);
return( NDS_ERRAPI);
}
}
printf( "Instrument_Manager() called with command %d (%s)\n", Command, Command_Name);
return( NDS_OK);
}
/*---------------------------------------------------------------------------------*/
/* */
/*---------------------------------------------------------------------------------*/
NDT_Status DR_Kit_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr)
{
NDT_Command_Name Command_Name;
switch( Command)
{
case NDD_CMD_MANAGER_VERSION:
{
ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *);
Command_Name = "NDD_CMD_MANAGER_VERSION";
*Version_Name_Ptr = "$Revision: 1.0 $ $Name: Kit_Manager $ $Date: 2021/12/12 21:27:12 $ $Author: agibert $";
return( NDS_OK);
}
case NDD_CMD_INDEX_GET:
{
/*
ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *);
ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *);
ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command);
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
*/
ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *);
ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *);
ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command);
ND_VA_ARG_GET( Kit_Ptr, *Args_Ptr, DRT_Kit *);
Command_Name = "NDD_CMD_INDEX_GET";
switch(Cmd)
{
/*
case NDT_CMD_SOME_USER_CMD:
{
*Reply_Index_Id_Ptr = 0;
*Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD;
break;
}
...
*/
case NDD_CMD_INDEX0_PRINT:
{
*Reply_Index_Id_Ptr = 0;
*Reply_Command_Ptr = Cmd;
break;
}
case NDD_CMD_VALUE_PRINT:
case NDD_CMD_INDEX1_PRINT:
{
*Reply_Index_Id_Ptr = 1;
*Reply_Command_Ptr = Cmd;
break;
}
default:
{
*Reply_Index_Id_Ptr = Index_Id;
*Reply_Command_Ptr = Cmd;
break;
}
}
return( NDS_OK);
}
case NDD_CMD_VALUE_ALLOC:
{
/*
ND_VA_ARG_GET( Value_Ptr_Ptr, *Args_Ptr, void **);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Kit_Ptr_Ptr, *Args_Ptr, DRT_Kit **);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( Name, user_args, char *);
ND_VA_ARG_GET( Desc, user_args, char *);
ND_VA_ARG_GET( FileName, user_args, char *);
ND_VA_LIST_CLOSE( user_args);
NDT_Status nd_status;
Command_Name = "NDD_CMD_VALUE_ALLOC";
if( ( *Kit_Ptr_Ptr = (DRT_Kit *)malloc( sizeof( DRT_Kit))) != NULL)
{
( *Kit_Ptr_Ptr)->Id = Root_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number;
strncpy( ( *Kit_Ptr_Ptr)->Name, Name, NAME_LEN);
strncpy( ( *Kit_Ptr_Ptr)->Desc, Desc, DESC_LEN);
strncpy( ( *Kit_Ptr_Ptr)->FileName, FileName, FILENAME_LEN);
(*Kit_Ptr_Ptr)->Name[ NAME_LEN] = '\0';
(*Kit_Ptr_Ptr)->Desc[ DESC_LEN] = '\0';
(*Kit_Ptr_Ptr)->FileName[FILENAME_LEN] = '\0';
if( ( nd_status = ND_DataStruct_Open( &((*Kit_Ptr_Ptr)->Instrument_DS_Ptr), DRD_INSTRUMENT_DS_INDEX_NB, DRG_Instrument_DS_Index_Tab_Initial, "Instrument_Manager", DR_Instrument_Manager, NULL, NULL, NULL, NULL, NDD_TRUE, NULL)) != NDS_OK)
{
printf( "DR_Instrument_Manager: ND_DataStruct_Open() failed (%d) !\n", nd_status);
return( NDS_KO);
}
return( NDS_OK);
}
else
{
return( NDS_KO);
}
}
case NDD_CMD_VALUE_FREE:
{
/*
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Kit_Ptr, *Args_Ptr, DRT_Kit *);
NDT_Status nd_status;
Command_Name = "NDD_CMD_VALUE_FREE";
if( ( nd_status = ND_DataStruct_Close( Kit_Ptr->Instrument_DS_Ptr)) != NDS_OK)
{
printf( "Can't close Kit_DS (%d)!\n", nd_status);
return( DRS_KO);
}
free( Kit_Ptr);
return( NDS_OK);
}
case NDD_CMD_VALUE_COMP:
{
/*
ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, void *);
ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Kit1_Ptr, *Args_Ptr, DRT_Kit *);
ND_VA_ARG_GET( Kit2_Ptr, *Args_Ptr, DRT_Kit *);
long rc;
Command_Name = "NDD_CMD_VALUE_COMP";
switch( Index_Id)
{
case 0:
{
rc = Kit1_Ptr->Id - Kit2_Ptr->Id;
break;
}
case 1:
{
rc = strcmp( Kit1_Ptr->Name, Kit2_Ptr->Name);
break;
}
default:
{
printf( "Unknown COMP idx (%d) !\n", Index_Id);
return( NDS_KO);
}
}
if( rc < 0)
{
return( NDS_LOWER);
}
else
{
if( rc > 0)
{
return( NDS_GREATER);
}
else
{
return( NDS_EQUAL);
}
}
}
case NDD_CMD_VALUE_ADD:
{
/*
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
Command_Name = "NDD_CMD_VALUE_ADD";
return( NDS_OK);
}
case NDD_CMD_VALUE_REMOVE:
{
/*
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
Command_Name = "NDD_CMD_VALUE_REMOVE";
return( NDS_OK);
}
case NDD_CMD_VALUE_PRINT:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
ND_VA_LIST_OPEN( user_args, lib_args);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
ND_VA_LIST_CLOSE( lib_args);
void *Value_Ptr = Node_Ptr->Value;
*/
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
ND_VA_LIST_OPEN( user_args, lib_args);
ND_VA_ARG_GET( Count_Ptr, user_args, long *);
ND_VA_LIST_CLOSE( user_args);
ND_VA_LIST_CLOSE( lib_args);
DRT_Kit *Kit_Ptr = Node_Ptr->Value;
Command_Name = "NDD_CMD_VALUE_PRINT";
if( DR_Kit_Dump( Kit_Ptr, ++(*Count_Ptr)) != DRS_OK)
{
return( NDS_KO);
}
else
{
return( NDS_OK);
}
}
case NDD_CMD_INFO_PRINT:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
ND_VA_LIST_OPEN( user_args, lib_args);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
ND_VA_LIST_CLOSE( lib_args);
*/
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
ND_VA_LIST_CLOSE( lib_args);
NDT_Status nd_status;
DRT_Kit *Kit_Ptr = Node_Ptr->Value;
Command_Name = "NDD_CMD_INFO_PRINT";
if( ( nd_status = ND_DataStruct_Info_Print( Out, Kit_Ptr->Instrument_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK)
{
printf( "ND_DataStruct_Info_Print() failed (%d) !\n", nd_status);
return( DRS_KO);
}
return( NDS_OK);
}
case NDD_CMD_INDEX0_PRINT:
case NDD_CMD_INDEX1_PRINT:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( Out, user_args, FILE *);
ND_VA_ARG_GET( Count_Ptr, user_args, long *);
ND_VA_LIST_CLOSE( user_args);
DRT_Kit *Kit_Ptr = Node_Ptr->Value;
Command_Name = "NDD_CMD_INDEX_PRINT";
if( DR_Kit_Dump( Kit_Ptr, ++(*Count_Ptr)) != DRS_OK)
{
return( NDS_KO);
}
else
{
return( NDS_OK);
}
}
/*
case NDD_CMD_PHONEBOOK_SAVE:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/ /*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( Out, user_args, FILE *);
ND_VA_ARG_GET( Count_Ptr, user_args, long *);
ND_VA_LIST_CLOSE( user_args);
DRT_Kit *Kit_Ptr = Node_Ptr->Value;
Command_Name = "NDD_CMD_PHONEBOOK_SAVE";
fprintf( Out, "%s:%s:%s:%s\n", Kit_Ptr->Number, Kit_Ptr->Name, Kit_Ptr->Address, Kit_Ptr->Email);
(*Count_Ptr)++;
return( NDS_OK);
}
*/
default:
{
printf( "Kit_Manager() called with an undefined command %d\n", Command);
return( NDS_ERRAPI);
}
}
printf( "Kit_Manager() called with command %d (%s)\n", Command, Command_Name);
return( NDS_OK);
}
/*---------------------------------------------------------------------------------*/
/* DR_Instrument_Add */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_Instrument_Add( DRT_Instrument **Instrument_Ptr_Ptr, NDT_Root *DS_Ptr, char *Name, char *FileName, double Gain, char *Sample_Ptr, long Sample_Size)
{
NDT_Status nd_status;
if( ( nd_status = ND_Value_Alloc( DS_Ptr, (void **)Instrument_Ptr_Ptr, Name, FileName, Gain, Sample_Ptr, Sample_Size)) != NDS_OK)
{
printf( "Can't allocate new instrument: ND_Value_Alloc() failed (%d) !\n", nd_status);
return( DRS_KO);
}
else
{
if( ( nd_status = ND_DataStruct_Value_Add( DS_Ptr, (void *)*Instrument_Ptr_Ptr)) != NDS_OK)
{
printf( "Can't add new kit: ND_Value_Add() failed (%d) !\n", nd_status);
return( DRS_KO);
}
}
return( DRS_OK);
}
/*---------------------------------------------------------------------------------*/
/* DR_Instrument_Dump */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_Instrument_Dump( DRT_Instrument *Instrument_Ptr, long count)
{
NDT_Status nd_status;
fprintf( stderr, " %03d) Instrument: ", count);
fprintf( stderr, " Id: (% 3d) Name: [%s] File Name: [%s] Gain: (%f) Sample: [%lx] Sample Size: (%d)\n",
Instrument_Ptr->Id, Instrument_Ptr->Name, Instrument_Ptr->FileName, Instrument_Ptr->Gain, Instrument_Ptr->Sample_Ptr, Instrument_Ptr->Sample_Size);
// fprintf( stderr, "\n");
return( DRS_OK);
}
/*---------------------------------------------------------------------------------*/
/* DR_Kit_Add */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_Kit_Add( DRT_Kit **Kit_Ptr_Ptr, NDT_Root *DS_Ptr, char *Name, char *Desc, char *FileName)
{
NDT_Status nd_status;
if( ( nd_status = ND_Value_Alloc( DS_Ptr, (void **)Kit_Ptr_Ptr, Name, Desc, FileName)) != NDS_OK)
{
printf( "Can't allocate new kit: ND_Value_Alloc() failed (%d) !\n", nd_status);
return( DRS_KO);
}
else
{
if( ( nd_status = ND_DataStruct_Value_Add( DS_Ptr, (void **)*Kit_Ptr_Ptr)) != NDS_OK)
{
printf( "Can't add new kit: ND_Value_Add() failed (%d) !\n", nd_status);
return( DRS_KO);
}
}
return( DRS_OK);
}
/*---------------------------------------------------------------------------------*/
/* DR_Kit_Dump */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_Kit_Dump( DRT_Kit *Kit_Ptr, long count)
{
NDT_Status nd_status;
long count2;
fprintf( stderr, " %03d) DrumKit:", count);
fprintf( stderr, " Id: (% 3d) Name: [%s] Descrition: [%.32s] File Name: [%s]\n", Kit_Ptr->Id, Kit_Ptr->Name, Kit_Ptr->Desc, Kit_Ptr->FileName);
fprintf( stderr, " Instruments List:\n");
if( Kit_Ptr->Instrument_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number == 0)
{
fprintf( stderr, " Empty list!\n");
}
else
{
count2 = 0;
if( ( nd_status = ND_DataStruct_Value_Print( stderr, Kit_Ptr->Instrument_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0, &count2)) != NDS_OK)
{
printf( "Cant't dump intruments: ND_DataStruct_Traverse() failed (%d) !\n", nd_status);
return( DRS_KO);
}
}
fprintf( stderr, "\n");
return( DRS_OK);
}
/*---------------------------------------------------------------------------------*/
/* DR_Kits_Load */
/*---------------------------------------------------------------------------------*/
void element_names_print( xmlNode *xml_node, int depth)
{
xmlNode *xml_cur_node;
for( xml_cur_node = xml_node; xml_cur_node; xml_cur_node = xml_cur_node->next)
{
if( xml_cur_node->type == XML_ELEMENT_NODE)
{
printf( "% *cnode type: Element, name: %s\n", depth*2, ' ', xml_cur_node->name);
}
element_names_print( xml_cur_node->children, depth + 1);
}
}
/*---------------------------------------------------------------------------------*/
/* DR_XML_Value_Get */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_XML_Value_Get( char *Value_Ptr, long Max_Len, xmlDocPtr Xml_Doc, xmlXPathContextPtr Xml_XpathCtx, char *Xpath_Request)
{
DRT_Status status;
xmlXPathObjectPtr xml_xpathobj;
xmlNodeSetPtr nodeset;
char *tmpval_ptr;
long tmpval_len;
if( ( xml_xpathobj = xmlXPathEvalExpression( Xpath_Request, Xml_XpathCtx)) == NULL)
{
fprintf( stderr, "xmlXPathEvalExpression failed!\n");
status = DRS_KO;
}
else
{
nodeset = xml_xpathobj->nodesetval;
if( xmlXPathNodeSetIsEmpty( nodeset))
{
fprintf( stderr, "[%s] not found!\n", Xpath_Request);
status = DRS_KO;
}
else
{
if( ( tmpval_ptr = xmlNodeListGetString( Xml_Doc, nodeset->nodeTab[0]->xmlChildrenNode, 1)) == NULL)
{
fprintf( stderr, "[%s] value not found!\n", Xpath_Request);
status = DRS_KO;
}
else
{
fprintf( stderr, "[%s] = [%s] found!\n", nodeset->nodeTab[0]->name, tmpval_ptr);
if( ( tmpval_len = strlen( tmpval_ptr)) > Max_Len)
{
fprintf( stderr, "Value too long (%d)>(%d)!\n", tmpval_len, Max_Len);
status = DRS_OK;
}
else
{
strcpy( Value_Ptr, tmpval_ptr);
status = DRS_OK;
}
}
xmlFree( tmpval_ptr);
}
}
return( status);
}
/*---------------------------------------------------------------------------------*/
/* DR_XML_Node_Exist */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_XML_Node_Exist( xmlDocPtr Xml_Doc, xmlXPathContextPtr Xml_XpathCtx, char *Xpath_Request)
{
DRT_Status status;
xmlXPathObjectPtr xml_xpathobj;
xmlNodeSetPtr nodeset;
char *tmpval_ptr;
long tmpval_len;
if( ( xml_xpathobj = xmlXPathEvalExpression( Xpath_Request, Xml_XpathCtx)) == NULL)
{
fprintf( stderr, "xmlXPathEvalExpression failed!\n");
status = DRS_KO;
}
else
{
nodeset = xml_xpathobj->nodesetval;
if( xmlXPathNodeSetIsEmpty( nodeset))
{
fprintf( stderr, "[%s] not found!\n", Xpath_Request);
status = DRS_KO;
}
else
{
fprintf( stderr, "[%s] found!\n", Xpath_Request);
status = DRS_OK;
}
}
return( status);
}
/*---------------------------------------------------------------------------------*/
/* DR_Kit_Load */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_Kit_Load( DRT_Base *Base_Ptr, char *FileName)
{
DRT_Status status;
NDT_Status nd_status;
DRT_Kit kit_template;
DRT_Kit *kit_ptr;
DRT_Instrument instrument_template;
DRT_Instrument *instrument_ptr;
char tmp_str[256];
char xpath_instrument[256];
char xpath_value[256];
xmlDocPtr xml_doc;
xmlXPathContextPtr xml_xpathCtx;
xmlXPathObjectPtr xml_xpathObj;
int i;
fprintf( stderr, "Loading: [%s]...\n", FileName);
if( strlen( FileName) > FILENAME_LEN)
{
fprintf( stderr, "Kit file name too long [%s]!", FileName);
status = DRS_KO;
}
else
{
strcpy( kit_template.FileName, FileName);
if( ( xml_doc = xmlParseFile( kit_template.FileName)) == NULL)
{
fprintf( stderr, "xml_doc failed!\n");
status = DRS_KO;
}
else
{
if( ( xml_xpathCtx = xmlXPathNewContext( xml_doc)) == NULL)
{
fprintf( stderr, "xmlXPathNewContext failed!\n");
status = DRS_KO;
}
else
{
if( xmlXPathRegisterNs( xml_xpathCtx, "drumkit", "http://www.hydrogen-music.org/drumkit") != 0)
{
fprintf( stderr,"Error: unable to register default NS!\n");
status = DRS_KO;
}
if( ( status = DR_XML_Node_Exist( xml_doc, xml_xpathCtx, XML_XPATH_DRUMKIT_BASE_STR) != DRS_OK))
{
fprintf( stderr, "Bad drumkit file!\n");
}
else
{
if( ( status = DR_XML_Value_Get( kit_template.Name, NAME_LEN, xml_doc, xml_xpathCtx, XML_XPATH_DRUMKIT_KIT_NAME_FULL)) != DRS_OK)
{
fprintf( stderr, "Name not found!\n");
}
else if( DR_XML_Value_Get( kit_template.Desc, DESC_LEN, xml_doc, xml_xpathCtx, XML_XPATH_DRUMKIT_KIT_INFO_FULL) != DRS_OK)
{
fprintf( stderr, "Info not found!\n");
strcpy( kit_template.Desc, "");
}
if( ( status = DR_Kit_Add( &kit_ptr, Base_Ptr->Kit_DS_Ptr, kit_template.Name, kit_template.Desc, kit_template.FileName)) != DRS_OK)
{
fprintf( stderr, "Can't create a new kit!\n");
}
else
{
fprintf( stderr, "New kit!\n");
status = DRS_OK;
i = 1;
while( ( status == DRS_OK)
&& ( sprintf( xpath_instrument, XML_XPATH_DRUMKIT_INSTRUMENT_FULL, i) > 0)
&& ( DR_XML_Node_Exist( xml_doc, xml_xpathCtx, xpath_instrument) == DRS_OK))
{
strcpy( xpath_value, xpath_instrument);
// strcat( xpath_value, "/drumkit:id");
strcat( xpath_value, XML_XPATH_DRUMKIT_ID_STR);
if( ( status = DR_XML_Value_Get( tmp_str, 256, xml_doc, xml_xpathCtx, xpath_value)) != DRS_OK)
{
fprintf( stderr, "Instrument id not found!\n");
}
else
{
instrument_template.Id = atoi( tmp_str);
strcpy( xpath_value, xpath_instrument);
// strcat( xpath_value, "/drumkit:name");
strcat( xpath_value, XML_XPATH_DRUMKIT_NAME_STR);
if( ( status = DR_XML_Value_Get( instrument_template.Name, NAME_LEN, xml_doc, xml_xpathCtx, xpath_value)) != DRS_OK)
{
fprintf( stderr, "Instrument name not found!\n");
strcpy( instrument_template.Name, "");
status = DRS_OK;
}
strcpy( xpath_value, xpath_instrument);
strcat( xpath_value, XML_XPATH_DRUMKIT_LAYER_FILENAME_STR);
if( ( status = DR_XML_Value_Get( instrument_template.FileName, FILENAME_LEN, xml_doc, xml_xpathCtx, xpath_value)) != DRS_OK)
{
fprintf( stderr, "Instrument file name not found!\n");
strcpy( instrument_template.FileName, "");
status = DRS_OK;
}
if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, instrument_template.Name, instrument_template.FileName, 1.01, NULL, 0)) != DRS_OK)
{
fprintf( stderr, "Can't create a new instrument!\n");
}
else
{
fprintf( stderr, "New Instrument!\n");
i++;
}
}
}
}
}
xmlXPathFreeContext( xml_xpathCtx);
}
xmlFreeDoc( xml_doc);
}
}
xmlCleanupParser();
return( status);
}
/*---------------------------------------------------------------------------------*/
/* DR_Kits_Load */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_Kits_Load( DRT_Base *Base_Ptr)
{
DRT_Status status;
NDT_Status nd_status;
char glob_pattern[] = "~/.hydrogen/data/drumkits/*/drumkit.xml";
// char glob_pattern[] = "~/.hydrogen/data/drumkits/AVL-BlackPearl-4A-1.1/drumkit.xml";
// char glob_pattern[] = "~/.hydrogen/data/drumkits/Mars Lindrum: 02-Kit 2/drumkit.xml";
glob_t glob_struct;
int i;
LIBXML_TEST_VERSION;
if( glob( glob_pattern, (GLOB_NOSORT + GLOB_TILDE), NULL, &glob_struct) != 0)
{
fprintf( stderr, "glob() error!\n");
status = DRS_KO;
}
else
{
for( i = 0; i < glob_struct.gl_pathc; i++)
{
// printf( "[%s]\n", glob_struct.gl_pathv[i]);
if( ( status = DR_Kit_Load( Base_Ptr, glob_struct.gl_pathv[i])) != DRS_OK)
{
fprintf( stderr, "Can't load kit [%s]!\n", glob_struct.gl_pathv[i]);
}
}
if( ( nd_status = ND_DataStruct_Convert( Base_Ptr->Kit_DS_Ptr, DRG_Kit_DS_Index_Tab_Final)) != NDS_OK)
{
fprintf( stderr, "ND_DataStruct_Convert() failed (%d) !\n", status);
status = DRS_KO;
}
else
{
status = DRS_OK;
}
}
globfree( &glob_struct);
return( status);
}
/*
if( ( xml_xpathObj = xmlXPathEvalExpression( "/drumkit:drumkit_info/drumkit:name", xml_xpathCtx)) == NULL)
{
fprintf( stderr, "xmlXPathEvalExpression failed!\n");
status = DRS_KO;
}
else
{
xmlNodeSetPtr nodeset = xml_xpathObj->nodesetval;
if( !xmlXPathNodeSetIsEmpty( xml_xpathObj->nodesetval))
{
fprintf( stderr, "Name [%s] found!\n", nodeset->nodeTab[0]->name);
int i;
char *keyword;
for( i=0; i < nodeset->nodeNr; i++)
{
keyword = xmlNodeListGetString( xml_doc, nodeset->nodeTab[i]->xmlChildrenNode, 1);
printf( "keyword: %s\n", keyword);
xmlFree( keyword);
}
}
DRT_Status DR_XML_Value_Get( char **Value_Ptr_Ptr, xmlDocPtr Xml_Doc, xmlXPathContextPtr xml_xpathCtx, char *Xpath_Request)
{
xmlXPathObjectPtr xml_xpathobj;
xmlNodeSetPtr nodeset;
if( ( xml_xpathobj = xmlXPathEvalExpression( "/drumkit:drumkit_info/drumkit:name", xml_xpathCtx)) == NULL)
{
fprintf( stderr, "xmlXPathEvalExpression failed!\n");
status = DRS_KO;
}
else
{
nodeset = xml_xpathobj->nodesetval;
if( !xmlXPathNodeSetIsEmpty( nodeset))
{
(*Value_Ptr_Ptr) = xmlNodeListGetString( Xml_Doc, nodeset->nodeTab[0]->xmlChildrenNode, 1);
fprintf( stderr, "[%s] = [%s] found!\n", nodeset->nodeTab[0]->name, *Value_Ptr_Ptr);
}
}
xmlXPathFreeObject(xml_xpathObj);
status = DRS_OK;
}
/*
xmlNodeSetPtr nodes = xml_xpathObj->nodesetval;
xmlNodePtr cur;
int size;
int i;
size = (nodes) ? nodes->nodeNr : 0;
fprintf( stderr, "Result (%d nodes):\n", size);
for( i = 0; i < size; ++i)
{
assert( nodes->nodeTab[i]);
if(nodes->nodeTab[i]->type == XML_NAMESPACE_DECL)
{
xmlNsPtr ns;
ns = (xmlNsPtr)nodes->nodeTab[i];
cur = (xmlNodePtr)ns->next;
if(cur->ns)
{
fprintf( stderr, "= namespace \"%s\"=\"%s\" for node %s:%s\n", ns->prefix, ns->href, cur->ns->href, cur->name);
}
else
{
fprintf( stderr, "= namespace \"%s\"=\"%s\" for node %s\n", ns->prefix, ns->href, cur->name);
}
}
else
{
if( nodes->nodeTab[i]->type == XML_ELEMENT_NODE)
{
cur = nodes->nodeTab[i];
if(cur->ns)
{
fprintf( stderr, "= element node \"%s:%s\"\n", cur->ns->href, cur->name);
}
else
{
fprintf( stderr, "= element node \"%s\"\n", cur->name);
}
}
else
{
cur = nodes->nodeTab[i];
fprintf( stderr, "= node \"%s\": type %d\n", cur->name, cur->type);
}
}
}
*/
/*
if( ( status = DR_Kit_Add( &kit_ptr, Base_Ptr->Kit_DS_Ptr, "Kit number one", "This is the best drumkit!", "/tmp/toto.xml")) != DRS_OK)
{
return( status);
}
if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 1.1", "/tmp/instrument-1.1.wav", 1.01, NULL, 0)) != DRS_OK)
{
return( status);
}
if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 1.2", "/tmp/instrument-1.2.wav", 2.01, NULL, 0)) != DRS_OK)
{
return( status);
}
if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 1.3", "/tmp/instrument-1.3.wav", 0.02, NULL, 0)) != DRS_OK)
{
return( status);
}
if( ( status = DR_Kit_Add( &kit_ptr, Base_Ptr->Kit_DS_Ptr, "Kit number two", "This is a good drumkit.", "/tmp/titi.xml")) != DRS_OK)
{
return( status);
}
if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 2.1", "/tmp/instrument-2.1.wav", 1.01, NULL, 0)) != DRS_OK)
{
return( status);
}
if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 2.2", "/tmp/instrument-2.2.wav", 2.01, NULL, 0)) != DRS_OK)
{
return( status);
}
if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, "Instrument 2.3", "/tmp/instrument-2.3.wav", 0.02, NULL, 0)) != DRS_OK)
{
return( status);
}
if( ( status = DR_Kit_Add( &kit_ptr, Base_Ptr->Kit_DS_Ptr, "Kit number three", "This is not the the best drum kit...", "/tmp/tata.xml")) != DRS_OK)
{
return( status);
}
*/
/*---------------------------------------------------------------------------------*/
/* DR_Kits_Dump */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_Kits_Dump( DRT_Base *Base_Ptr)
{
NDT_Status nd_status;
short index;
long count = 0;
fprintf( stderr, "DrumKit List:\n");
if( ( nd_status = ND_DataStruct_Info_Print( stderr, Base_Ptr->Kit_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK)
{
printf( "ND_DataStruct_Info_Print() failed (%d) !\n", nd_status);
return( DRS_KO);
}
/*
for( index = 0; index < Base_Ptr->Kit_DS_Ptr->Index_Nb; index++)
{
count = 0;
fprintf( stderr, "Dump Index: (%d)\n", index);
if( Base_Ptr-> Kit_DS_Ptr->Index_Tab[index].Node_Number == 0)
{
fprintf( stderr, " Empty list!\n");
}
else
{
if( ( nd_status = ND_DataStruct_Traverse( Base_Ptr->Kit_DS_Ptr, (NDD_CMD_INDEX0_PRINT + index), stderr, &count)) != NDS_OK)
{
printf( "Can't dump kits: ND_DataStruct_Traverse() failed (%d) !\n", nd_status);
return( DRS_KO);
}
}
fprintf( stderr, "\n");
}
*/
if( ( nd_status = ND_DataStruct_Value_Print( stderr, Base_Ptr->Kit_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0, &count)) != NDS_OK)
{
printf( "Can't dump kits: ND_DataStruct_Value_Print() failed (%d) !\n", nd_status);
return( DRS_KO);
}
return( DRS_OK);
}
/*---------------------------------------------------------------------------------*/
/* DR_Init */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_Init( DRT_Base *Base_Ptr)
{
NDT_Status nd_status;
if( ( nd_status = ND_Library_Open( NDD_TRUE)) != NDS_OK)
{
fprintf( stderr, "Can't open node library (%d) !", nd_status);
return( DRS_KO);
}
if( ( nd_status = ND_DataStruct_Open( &(Base_Ptr->Kit_DS_Ptr), DRD_KIT_DS_INDEX_NB, DRG_Kit_DS_Index_Tab_Initial, "Kit_Manager", DR_Kit_Manager, NULL, NULL, NULL, NULL, NDD_TRUE, NULL)) != NDS_OK)
{
printf( "Kit_DS: ND_DataStruct_Open() failed (%d) !\n", nd_status);
return( DRS_KO);
}
return( DRS_OK);
}
/*---------------------------------------------------------------------------------*/
/* DR_DeInit */
/*---------------------------------------------------------------------------------*/
DRT_Status DR_DeInit( DRT_Base *Base_Ptr)
{
NDT_Status nd_status;
if( ( nd_status = ND_DataStruct_Close( Base_Ptr->Kit_DS_Ptr)) != NDS_OK)
{
printf( "Can't close Kit_DS (%d)!\n", nd_status);
return( DRS_KO);
}
if( ( nd_status = ND_Library_Close()) != NDS_OK)
{
fprintf( stderr, "Can't close node library (%d)!", nd_status);
return( DRS_KO);
}
return( DRS_OK);
}
/*---------------------------------------------------------------------------------*/
/* main */
/*---------------------------------------------------------------------------------*/
int main( int argc, char **argv)
{
DRT_Base base;
DRT_Status status;
if( ( status = DR_Init( &base)) != DRS_OK)
{
exit( -1);
}
if( ( status = DR_Kits_Load( &base)) != DRS_OK)
{
exit( -1);
}
printf( "hello world!\n");
if( ( status = DR_Kits_Dump( &base)) != DRS_OK)
{
exit( -1);
}
if( ( status = DR_DeInit( &base)) != DRS_OK)
{
exit( -1);
}
exit( 0);
}
Reference in New Issue Copy Permalink