From 72db530dbf62b113f05be60e832fa89bab1cecaf Mon Sep 17 00:00:00 2001 From: agibert Date: Mon, 17 Dec 2001 01:07:47 +0000 Subject: [PATCH] Initial creation. --- ReadMe.txt | 0 ReleaseNotes.txt | 0 ToDo.txt | 0 lib/Makefile | 11 + lib/libopt.c | 1444 ++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 1455 insertions(+) create mode 100644 ReadMe.txt create mode 100644 ReleaseNotes.txt create mode 100644 ToDo.txt create mode 100644 lib/Makefile create mode 100644 lib/libopt.c diff --git a/ReadMe.txt b/ReadMe.txt new file mode 100644 index 0000000..e69de29 diff --git a/ReleaseNotes.txt b/ReleaseNotes.txt new file mode 100644 index 0000000..e69de29 diff --git a/ToDo.txt b/ToDo.txt new file mode 100644 index 0000000..e69de29 diff --git a/lib/Makefile b/lib/Makefile new file mode 100644 index 0000000..6dad628 --- /dev/null +++ b/lib/Makefile @@ -0,0 +1,11 @@ + +all: libopt.so + +libnode.o: libopt.c opt.h libopt.h Makefile + gcc -c -g -o libopt.o -I . libopt.c + +libnode.so: libnode.o + ld -shared -o libopt.so libopt.o + +clean: + rm libopt.o libopt.so diff --git a/lib/libopt.c b/lib/libopt.c new file mode 100644 index 0000000..61ae526 --- /dev/null +++ b/lib/libopt.c @@ -0,0 +1,1444 @@ +/*---------------------------------------------------------------------------------*/ +/* $RCSfile: libopt.c,v $ */ +/*---------------------------------------------------------------------------------*/ +/* $Revision: 1.1 $ */ +/* $Name: $ */ +/* $Date: 2001/12/17 01:12:41 $ */ +/* $Author: agibert $ */ +/*---------------------------------------------------------------------------------*/ + + + +#define _OPTION_C_ + +#include "tima.h" + + + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +NDT_Status Manager_OptionValueStruct( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list Args) +{ + NDT_Command_Name Command_Name; + + + switch( Command) + { + case NDD_CMD_MANAGER_VERSION: + { + NDT_Version_Name *Version_Name_Ptr = (NDT_Version_Name *)va_arg( Args, NDT_Version_Name *); + + Command_Name = "NDD_CMD_MANAGER_VERSION"; + + *Version_Name_Ptr = "$Revision: 1.1 $ $Name: $ $Date: 2001/12/17 01:12:41 $ $Author: agibert $"; + + return( NDS_OK); + } + + case NDD_CMD_INDEX_GET: + { + /* + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + */ + NDT_Index_Id *Reply_Index_Id_Ptr = (NDT_Index_Id *)va_arg( Args, NDT_Index_Id *); + NDT_Command *Reply_Command_Ptr = (NDT_Command *)va_arg( Args, NDT_Command *); + NDT_Command Cmd = (NDT_Command)va_arg( Args, NDT_Command); + + + Command_Name = "NDD_CMD_IDX_GET"; + + switch(Cmd) + { + /* + case NDT_CMD_SOME_USER_CMD: + { + *Reply_Index_Id_Ptr = 0; + *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD; + break; + } + + + ... + */ + + default: + { + *Reply_Index_Id_Ptr = Index_Id; + *Reply_Command_Ptr = Cmd; + break; + } + } + + return( NDS_OK); + } + + case NDD_CMD_VALUE_ALLOC: + { + /* + void **Value_Ptr_Ptr = (void **)va_arg( Args, void **); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + TIMAT_OptionValue **OptionValue_Ptr_Ptr = (TIMAT_OptionValue **)va_arg( Args, TIMAT_OptionValue **); + + + Command_Name = "NDD_CMD_VALUE_ALLOC"; + + if( ( *OptionValue_Ptr_Ptr = (void *)malloc( sizeof(TIMAT_OptionValue))) == NULL) + { + return(NDS_ERRMEM); + } + else + { + (*OptionValue_Ptr_Ptr)->Node = NULL; + (*OptionValue_Ptr_Ptr)->Data[0] = '\0'; + return( NDS_OK); + } + + } + + case NDD_CMD_VALUE_FREE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + TIMAT_OptionValue *OptionValue_Ptr = (TIMAT_OptionValue *)va_arg( Args, TIMAT_OptionValue *); + + + Command_Name = "NDD_CMD_VALUE_FREE"; + + free( OptionValue_Ptr); + + return( NDS_OK); + } + + case NDD_CMD_VALUE_COMP: + { + /* + void *Value1_Ptr = (void *)va_arg( Args, void *); + void *Value2_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_COMP"; + + /* + switch( Index_Id) + { + case 0: + { + int rc; + + + rc = strcmp( Value1_Ptr->..., Value2_Ptr->...); + + if( rc < 0) + { + return(NDS_LOWER); + } + else + { + if( rc > 0) + { + return(NDS_GREATER); + } + else + { + return(NDS_EQUAL); + } + } + } + + case 1: + { + int val1 = atoi(Value1_Ptr->...); + int val2 = atoi(Value2_Ptr->...); + + + if( val1 < val2) + { + return(NDS_LOWER); + } + else + { + if( val1 > val2) + { + return(NDS_GREATER); + } + else + { + return(NDS_EQUAL); + } + } + } + + case 2: + { + ... + } + + default: + { + printf( "Unknown COMP idx (%d) !\n", Index_Id); + return( NDS_KO); + } + } + + return( NDS_OK); + */ + } + + case NDD_CMD_VALUE_ADD: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + TIMAT_OptionValue *OptionValue_Ptr = (TIMAT_OptionValue *)va_arg( Args, TIMAT_OptionValue *); + + + Command_Name = "NDD_CMD_VALUE_ADD"; + + OptionValue_Ptr->Node = Node_Ptr; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_REMOVE: + { + /* + void *Value_Ptr = (void *)va_arg( Args, void *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + */ + + + Command_Name = "NDD_CMD_VALUE_REMOVE"; + + return( NDS_OK); + } + + case NDD_CMD_VALUE_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + + TIMAT_OptionValue *OptionValue_Ptr = Node_Ptr->Value; + + + Command_Name = "NDD_CMD_VALUE_PRINT"; + + fprintf( Out, "["); + TIMA_Opt_OptionValue_Print( Out, OptionValue_Ptr); + fprintf( Out, "] "); + + return( NDS_OK); + } + + case NDD_CMD_INFO_PRINT: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list lib_args = (va_list)va_arg( Args, va_list); + FILE *Out = (FILE *)va_arg( lib_args, FILE *); + NDT_Recursive_Mode Recursive_Mode = (NDT_Recursive_Mode)va_arg( lib_args, NDT_Recursive_Mode); + NDT_Recursive_Depth Recursive_Depth = (NDT_Recursive_Depth)va_arg( lib_args, NDT_Recursive_Depth); + va_list user_args = (va_list)va_arg( lib_args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + + Command_Name = "NDD_CMD_INFO_PRINT"; + + return( NDS_OK); + } + + case NDD_CMD_USER_TRAVERSE: + { + /* + NDT_Node *Next_Node_Ptr = (NDT_Node *)va_arg( Args, NDT_Node *); + va_list user_args = (va_list)va_arg( Args, va_list); + user_type user_data = (user_type)va_arg( user_args, user_type); + ... = (...)va_arg( user_args, ...); + + void *Value_Ptr = Node_Ptr->Value; + */ + + + Command_Name = "NDD_CMD_USER_TRAVERSE"; + + /* + return( NDS_OK); + */ + } + + default: + { + printf( "Default_Manager() called with an undefined command %d\n", Command); + return(NDS_ERRAPI); + } + } + + printf( "Default_Manager() called with command %d (%s)\n", Command, Command_Name); + return(NDS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status TIMA_Opt_Eval( char *Output_Str, int Output_Size, char *Input_Str) +{ + char *cmd_prefix = "echo "; + char *command_ptr; + int old_stdout, pipe[2]; + + + if( ( command_ptr = malloc( strlen( cmd_prefix) + strlen( Input_Str) + 1)) == NULL) + { + printf( "TIMA_Opt_Eval: malloc() failed !\n"); + return(TIMAS_OK); + } + + sprintf( command_ptr, "%s%s", cmd_prefix, Input_Str); + + + + if( ( old_stdout = _dup( _fileno( stdout))) == -1) + { + printf( "TIMA_Opt_Eval: _dup2() failed !\n"); + return(TIMAS_OK); + } + + if( _pipe( pipe, 1024, _O_BINARY) == -1) + { + printf( "TIMA_Opt_Eval: _pipe() failed !\n"); + return(TIMAS_OK); + } + + if( _dup2( pipe[1], _fileno( stdout)) == -1) + { + printf( "TIMA_Opt_Eval: _dup2() failed !\n"); + return(TIMAS_OK); + } + + + + if( system( command_ptr) == -1) + { + printf( "TIMA_Opt_Eval: system() failed !\n"); + return(TIMAS_OK); + } + + if( fflush( stdout) != 0) + { + printf( "TIMA_Opt_Eval: fflush() failed !\n"); + return(TIMAS_OK); + } + + + + Output_Str[ _read( pipe[0], Output_Str, Output_Size) - 2] = '\0'; + + if( _dup2( old_stdout, _fileno( stdout)) == -1) + { + printf( "TIMA_Opt_Eval: _dup2() failed !\n"); + return(TIMAS_OK); + } + + if( _close( pipe[0]) == -1) + { + printf( "TIMA_Opt_Eval: _close() failed !\n"); + return(TIMAS_OK); + } + + if( _close( pipe[1]) == -1) + { + printf( "TIMA_Opt_Eval: _close() failed !\n"); + return(TIMAS_OK); + } + + free( command_ptr); + + return( TIMAS_OK); + +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status Opt_Option_String_Parse( int *argc, char **argv, char *Input_String) +{ + short i, j; + short new_arg; + + + for( i = 0, j = 0, new_arg = 1; ( i < 1024) && ( Input_String[i] != '\0'); i++) + { + if( ( Input_String[i] == ' ') || ( Input_String[i] == '\t') || ( Input_String[i] == '\r') || ( Input_String[i] == '\n')) + { + Input_String[i] = '\0'; + new_arg = 1; + } + else + { + if( Input_String[i] == '#') + { + Input_String[i--] = '\0'; + } + else + { + if( new_arg) + { + new_arg = 0; + argv[j++] = &Input_String[i]; + } + } + } + } + + *argc = j; + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status Opt_Option_Value_Copy( TIMAT_Option *Option_Tab, short Opt, short Env, int *ArgNb_Ptr, int ArgC, char **ArgV, short Switch) +{ + NDT_Status nd_status; + short arg; + TIMAT_OptionValue *optionvalue_ptr; + TIMAT_OptionValue value; + + + if( Option_Tab[Opt].Arg_Type == TIMAD_OPTION_ARG_TYPE_MONO) + { + if( Option_Tab[Opt].Arg_Number > 2) + { + if( Option_Tab[Opt].OptionValueStruct_Tab[Env] != NULL) + { + if( ( nd_status = ND_DataStruct_Flush( Option_Tab[Opt].OptionValueStruct_Tab[Env])) != NDS_OK) + { + printf( "Opt_Option_Value_Copy: ND_DataStructure_Flush() failed (%d) !\n", nd_status); + return( TIMAS_KO); + } + } + } + } + + if( ( Option_Tab[Opt].Arg_Number - 1) > ArgC) + { + printf( "Opt_Option_Value_Copy: Missing option value for [%s] !\n", Option_Tab[Opt].Switch_Long); + return( TIMAS_KO); + } + + arg = 0; + + do + { + if( Option_Tab[Opt].Arg_Number == 1) + { + value.Type = Option_Tab[Opt].Value_Type_Tab[0]; + value.Data[0] = (char)Switch; + value.Node = NULL; + } + else + { + value.Type = Option_Tab[Opt].Value_Type_Tab[ arg % ( Option_Tab[Opt].Arg_Number - 1)]; + value.Node = NULL; + + if( *(char *)( ArgV[arg]) == TIMAD_UNKNOWN) + { + *((char *)value.Data) = TIMAD_UNKNOWN; + } + else + { + switch( value.Type) + { + case TIMAD_OPTION_VALUE_TYPE_UNKNOWN: + { + *((char *)value.Data) = TIMAD_UNKNOWN; + break; + } + + case TIMAD_OPTION_VALUE_TYPE_FLAG: + { + *((char *)value.Data) = ArgV[arg][0]; + break; + } + + case TIMAD_OPTION_VALUE_TYPE_LONG: + { + *((long *)value.Data) = atoi( ArgV[arg]); + break; + } + + case TIMAD_OPTION_VALUE_TYPE_STRING: + { + strcpy( value.Data, ArgV[arg]); + break; + } + + default: + { + printf( "Opt_Option_Value_Copy: Unknown option value type (%d) !\n", value.Type); + return( TIMAS_KO); + } + } + } + } + + if( Option_Tab[Opt].Arg_Type == TIMAD_OPTION_ARG_TYPE_MONO) + { + Option_Tab[Opt].OptionValueData_Tab[Env].Type = value.Type; + strncpy( Option_Tab[Opt].OptionValueData_Tab[Env].Data, value.Data, TIMAD_OPTION_VALUE_LEN); + Option_Tab[Opt].OptionValueData_Tab[Env].Node = NULL; + } + else + { + if( ( nd_status = ND_Value_Alloc( Option_Tab[Opt].OptionValueStruct_Tab[Env], (void **)&optionvalue_ptr)) != NDS_OK) + { + printf( "Opt_Option_Value_Copy: ND_Value_Alloc() failed (%d) !\n", nd_status); + return( TIMAS_KO); + } + + optionvalue_ptr->Type = value.Type; + strncpy( optionvalue_ptr->Data, value.Data, TIMAD_OPTION_VALUE_LEN); + + if( ( nd_status = ND_DataStruct_Value_Add( Option_Tab[Opt].OptionValueStruct_Tab[Env], optionvalue_ptr)) != NDS_OK) + { + printf( "Opt_Option_Value_Copy: ND_DataStruct_Value_Add() failed (%d) !\n", nd_status); + return( TIMAS_KO); + } + } + + arg++; + } + while( arg < ArgC); + + if( Option_Tab[Opt].Arg_Number == 1) + { + *ArgNb_Ptr = 0; + } + else + { + *ArgNb_Ptr = arg; + } + + return(TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status Opt_Option_Init( TIMAT_Option *Option_Tab) +{ + NDT_Status nd_status; + TIMAT_Status status; + short opt,env; + char val_def[TIMAD_OPTION_ARG_NUMBER_MAX * ( TIMAD_OPTION_VALUE_SIZE + 1)]; + TIMAT_OptionValueData val_tmp; + int argc, argnb; + char *argv[255]; + + + for( opt = 1; Option_Tab[opt].Arg_Number != 0; opt++) + { + for( env = 0; env < TIMAD_OPTION_ENV_NUMBER; env++) + { + if( Option_Tab[opt].Arg_Type == TIMAD_OPTION_ARG_TYPE_MULTI) + { + if( ( nd_status = ND_DataStruct_Open( &( Option_Tab[opt].OptionValueStruct_Tab[env]), 1, TIMAG_OptionValue_Type_Initial_Tab, \ + "Manager_OptionValueStruct", Manager_OptionValueStruct, NULL, NULL, NULL, NULL, \ + 0, NULL)) != NDS_OK) + { + printf( "Opt_Option_Init: ND_DataStruct_Open() OptionStruct failed: (%d)...\n", nd_status); + return( TIMAS_KO); + } + } + + if( env == TIMAD_OPTION_ENV_DEFAULT) + { + if( *((char *)Option_Tab[opt].OptionValueData_Flat_Default) != TIMAD_UNKNOWN) + { + strcpy( val_def, Option_Tab[opt].OptionValueData_Flat_Default); + + if( ( status = Opt_Option_String_Parse( &argc, argv, val_def)) != TIMAS_OK) + { + printf( "Opt_Option_Init: Opt_Option_String_Parse() failed: (%d)...\n", status); + return( TIMAS_KO); + } + } + else + { + argc = 1; + val_tmp[0] = (char)TIMAD_UNKNOWN; + argv[0] = val_tmp; + } + } + else + { + argc = 1; + val_tmp[0] = (char)TIMAD_UNKNOWN; + argv[0] = val_tmp; + } + + if( ( *((char *)argv[0]) != TIMAD_UNKNOWN) || ( Option_Tab[opt].Arg_Type == TIMAD_OPTION_ARG_TYPE_MONO)) + { + if( ( status = Opt_Option_Value_Copy( Option_Tab, opt, env, &argnb, argc, argv, Option_Tab[opt].OptionValueData_Flat_Default[0])) != TIMAS_OK) + { + printf( "Opt_Option_Init: Opt_Option_Value_Copy() failed: (%d)...\n", status); + return( TIMAS_KO); + } + } + } + } + + return( TIMAS_OK); +} + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status Opt_Option_DeInit( TIMAT_Option *Option_Tab) +{ + NDT_Status nd_status; + short i, j; + + + for( i = 1; Option_Tab[i].Arg_Number != 0; i++) + { + if( Option_Tab[i].Arg_Type == TIMAD_OPTION_ARG_TYPE_MULTI) + { + for( j = 1; j < TIMAD_OPTION_ENV_NUMBER; j++) + { + if( Option_Tab[i].OptionValueStruct_Tab[j] != NULL) + { + if( ( nd_status = ND_DataStruct_Close( Option_Tab[i].OptionValueStruct_Tab[j])) != NDS_OK) + { + printf( "Opt_Option_DeInit: ND_DataStruct_Close OptionStruct failled: (%d)...\n", nd_status); + } + } + } + } + } + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status TIMA_Opt_Init( void) +{ + TIMAT_Status status; + + + if( ( status = Opt_Option_Init( TIMAG_Option_Tab)) != TIMAS_OK) + { + printf( "TIMA_Opt_Init: Opt_Option_Init() failed: (%d)...\n", status); + return( TIMAS_KO); + } + + printf( "TIMA_Opt_Init Ok !\n"); + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status TIMA_Opt_DeInit( void) +{ + TIMAT_Status status; + + + if( ( status = Opt_Option_DeInit( TIMAG_Option_Tab)) != TIMAS_OK) + { + printf( "TIMA_Opt_DeInit: Opt_Option_Init() failed: (%d)...\n", status); + return( TIMAS_KO); + } + + printf( "TIMA_Opt_DeInit Ok !\n"); + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status Opt_Option_Value_Load( TIMAT_Option *Option_Tab, short Env, int *ArgNb_Ptr, int ArgC, char **ArgV) +{ + NDT_Status nd_status; + TIMAT_Status status; + char *option_name; + short name_type; + short swtch; + short i; + + + if( *(ArgV[0]) == '-') + { + if( *(ArgV[0] + 1) == '-') + { + option_name = ArgV[0] + 2; + name_type = TIMAD_OPTION_NAME_TYPE_LONG; + } + else + { + option_name = ArgV[0] + 1; + name_type = TIMAD_OPTION_NAME_TYPE_SHORT; + } + } + else + { + printf( "TIMA_Opt_Option_Value_Load: Invalid command line string [%s]...\n", ArgV[0]); + return( TIMAS_KO); + } + + for( i = 1; Option_Tab[i].Arg_Number != 0; i++) + { + if( Option_Tab[i].Arg_Number == 1) + { + if( name_type == TIMAD_OPTION_NAME_TYPE_LONG) + { + if( !strcmp( Option_Tab[i].Switch_On_Long, option_name)) + { + swtch = TIMAD_TRUE; + break; + } + + if( !strcmp( Option_Tab[i].Switch_Off_Long, option_name)) + { + swtch = TIMAD_FALSE; + break; + } + } + else + { + if( !strcmp( Option_Tab[i].Switch_On_Short, option_name)) + { + swtch = TIMAD_TRUE; + break; + } + + if( !strcmp( Option_Tab[i].Switch_Off_Short, option_name)) + { + swtch = TIMAD_FALSE; + break; + } + } + } + else + { + if( name_type == TIMAD_OPTION_NAME_TYPE_LONG) + { + if( !strcmp( Option_Tab[i].Switch_Long, option_name)) break; + } + else + { + if( !strcmp( Option_Tab[i].Switch_Short, option_name)) break; + } + } + } + + if( Option_Tab[i].Arg_Number == 0) + { + printf( "TIMA_Opt_Option_Value_Load: Unknown option [%s]...\n", ArgV[0]); + return( TIMAS_KO); + } + + if( Option_Tab[i].Arg_Type == TIMAD_OPTION_ARG_TYPE_MONO) + { + if( Option_Tab[i].Arg_Number > 2) + { + if( Option_Tab[i].OptionValueStruct_Tab[Env] != NULL) + { + if( ( nd_status = ND_DataStruct_Flush( Option_Tab[i].OptionValueStruct_Tab[Env])) != NDS_OK) + { + printf( "Opt_Option_Value_Load: ND_DataStructure_Flush() failed (%d) !\n", nd_status); + return( TIMAS_KO); + } + } + } + } + + if( Option_Tab[i].Arg_Number > ArgC) + { + printf( "TIMA_Opt_Option_Value_Load: Missing option value for [%s] !\n", ArgV[0]); + return( TIMAS_KO); + } + + if( ( status = Opt_Option_Value_Copy( Option_Tab, i, Env, ArgNb_Ptr, (Option_Tab[i].Arg_Number - 1), (ArgV + 1), swtch)) != TIMAS_OK) + { + printf( "Opt_Option_Init: Opt_Option_Value_Copy() failed: (%d)...\n", status); + return( TIMAS_KO); + } + + (*ArgNb_Ptr)++; + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status Opt_Option_Arg_Parse( TIMAT_Option *Option_Tab, short Env, int ArgC, char **ArgV) +{ + TIMAT_Status status; + int argnb; + short i; + + + for( i = 1; i < ArgC; i += argnb) + { + if( ( status = Opt_Option_Value_Load( Option_Tab, Env, &argnb, ( ArgC - i), &(ArgV[i]))) != TIMAS_OK) + { + printf( "TIMA_Opt_Option_Arg_Parse: Can't load value (%d)...\n", status); + return( TIMAS_KO); + } + } + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status Opt_Option_File_Parse( TIMAT_Option *Option_Tab, short Env, char *Config_File_Name) +{ + TIMAT_Status status; + FILE *config_file; + char buf[1025] = "--"; + int argc; + char *argv[255]; + int argnb; + + + if( ( config_file = fopen( Config_File_Name, "r")) == NULL) + { + fprintf( stderr, "Opt_Option_File_Parse: can't open config file [%s] !\n", Config_File_Name); + return( TIMAS_OK); + } + + while( ( !feof( config_file)) && ( fgets( (buf + 2), 1022, config_file) != NULL)) + { + if( ( status = Opt_Option_String_Parse( &argc, argv, buf)) != TIMAS_OK) + { + printf( "Opt_Option_File_Parse: Opt_Option_String_Parse() failed (%d)...\n", status); + return( TIMAS_KO); + } + + if( argc > 0) + { + if( ( status = Opt_Option_Value_Load( Option_Tab, Env, &argnb, argc, argv)) != TIMAS_OK) + { + printf( "Opt_Option_File_Parse: Can't load value (%d)...\n", status); + return( TIMAS_KO); + } + } + } + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status Opt_Option_Env_Copy( TIMAT_Option *Option_Tab, short Dst_Env, short Src_Env) +{ + + TIMAT_Status status; + NDT_Status nd_status; + short opt; + TIMAT_OptionValue *value_next_ptr, *value_new_ptr; + + + for( opt = 1; Option_Tab[opt].Arg_Number != 0 ; opt++) + { + if( ( Option_Tab[opt].Arg_Type == TIMAD_OPTION_ARG_TYPE_MONO) && ( Option_Tab[opt].Arg_Number <= 2)) + { + if( Option_Tab[opt].OptionValueData_Tab[Src_Env].Data[0] != TIMAD_UNKNOWN) + { + Option_Tab[opt].OptionValueData_Tab[Dst_Env].Type = Option_Tab[opt].OptionValueData_Tab[Src_Env].Type; + strncpy( Option_Tab[opt].OptionValueData_Tab[Dst_Env].Data, Option_Tab[opt].OptionValueData_Tab[Src_Env].Data, TIMAD_OPTION_VALUE_SIZE); + Option_Tab[opt].OptionValueData_Tab[Dst_Env].Node = Option_Tab[opt].OptionValueData_Tab[Src_Env].Node; + + } + } + else + { + if( Option_Tab[opt].OptionValueStruct_Tab[Src_Env]->Index_Tab[NDD_INDEX_PRIMARY].Node_Number > 0) + { + if( Option_Tab[opt].Arg_Type == TIMAD_OPTION_ARG_TYPE_MONO) + { + if( Option_Tab[opt].OptionValueStruct_Tab[Dst_Env] != NULL) + { + if( ( nd_status = ND_DataStruct_Flush( Option_Tab[opt].OptionValueStruct_Tab[Dst_Env])) != NDS_OK) + { + printf( "Opt_Option_Env_Copy: ND_DataStructure_Flush() failed (%d) !\n", nd_status); + return( TIMAS_KO); + } + } + } + + value_next_ptr = NULL; + + do + { + if( ( status = TIMA_Opt_OptionValue_Next( &value_next_ptr, value_next_ptr, &Option_Tab[opt], Src_Env)) != TIMAS_OK) + { + printf( "Opt_Option_Value_Load: TIMA_OptionValue_Next() failed (%d) !\n", status); + return( TIMAS_KO); + } + + if( value_next_ptr != NULL) + { + if( ( nd_status = ND_Value_Alloc( Option_Tab[opt].OptionValueStruct_Tab[Dst_Env], (void **)&value_new_ptr)) != NDS_OK) + { + printf( "Opt_Option_Value_Load: ND_Value_Alloc() failed (%d) !\n", nd_status); + return( TIMAS_KO); + } + + value_new_ptr->Type = value_next_ptr->Type; + strncpy( value_new_ptr->Data, value_next_ptr->Data, TIMAD_OPTION_VALUE_LEN); + + if( ( nd_status = ND_DataStruct_Value_Add( Option_Tab[opt].OptionValueStruct_Tab[Dst_Env], value_new_ptr)) != NDS_OK) + { + printf( "Opt_Option_Value_Load: ND_DataStruct_Value_Add() failed (%d) !\n", nd_status); + return( TIMAS_KO); + } + } + } + while( value_next_ptr != NULL); + } + } + } + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status TIMA_Opt_Option_Load( int ArgC, char **ArgV) +{ + TIMAT_Status status; + char cscs_path[TIMAD_OPTION_VALUE_SIZE]; + char *config_file_name; + char config_file_path[TIMAD_OPTION_VALUE_SIZE]; + + + /* Initial command line loading */ + + if( ( status = Opt_Option_Arg_Parse( TIMAG_Option_Tab, TIMAD_OPTION_ENV_COMMAND, ArgC, ArgV)) != TIMAS_OK) + { + printf( "TIMA_Opt_Option_Load: Opt_Option_Arg_Parse() Command Env failed (%d) !\n", status); + return( TIMAS_KO); + } + + + + /* CSCS dir handling */ + + if( TIMAG_Option_Tab[TIMAD_OPTION_ID_CSCS_DIR].OptionValueData_Tab[TIMAD_OPTION_ENV_COMMAND].Data[0] != TIMAD_UNKNOWN) + { + strcpy( cscs_path, TIMAG_Option_Tab[TIMAD_OPTION_ID_CSCS_DIR].OptionValueData_Tab[TIMAD_OPTION_ENV_COMMAND].Data); + } + else + { + if( TIMAG_Option_Tab[TIMAD_OPTION_ID_CSCS_DIR].OptionValueData_Tab[TIMAD_OPTION_ENV_DEFAULT].Data[0] != TIMAD_UNKNOWN) + { + strcpy( cscs_path, TIMAG_Option_Tab[TIMAD_OPTION_ID_CSCS_DIR].OptionValueData_Tab[TIMAD_OPTION_ENV_DEFAULT].Data); + } + else + { + printf( "CSCSPATH not found !\n"); + exit( -1); + } + } + + if( ( status = TIMA_Opt_Eval( cscs_path, TIMAD_OPTION_VALUE_SIZE, cscs_path)) != TIMAS_OK) + { + printf( "TIMA_Opt_Option_Load: TIMA_Opt_Eval() failed (%d) !\n", status); + return( TIMAS_KO); + } + + + + /* Config file handling */ + + if( TIMAG_Option_Tab[TIMAD_OPTION_ID_CONFIG_FILE].OptionValueData_Tab[TIMAD_OPTION_ENV_COMMAND].Data[0] != TIMAD_UNKNOWN) + { + config_file_name = TIMAG_Option_Tab[TIMAD_OPTION_ID_CONFIG_FILE].OptionValueData_Tab[TIMAD_OPTION_ENV_COMMAND].Data; + } + else + { + if( TIMAG_Option_Tab[TIMAD_OPTION_ID_CONFIG_FILE].OptionValueData_Tab[TIMAD_OPTION_ENV_DEFAULT].Data[0] != TIMAD_UNKNOWN) + { + config_file_name = TIMAG_Option_Tab[TIMAD_OPTION_ID_CONFIG_FILE].OptionValueData_Tab[TIMAD_OPTION_ENV_DEFAULT].Data; + } + else + { + config_file_name = NULL; + } + } + + if( config_file_name != NULL) + { + sprintf( config_file_path, "%s\\%s", cscs_path, config_file_name); + + if( ( status = Opt_Option_File_Parse( TIMAG_Option_Tab, TIMAD_OPTION_ENV_CONFIG, config_file_path)) != TIMAS_OK) + { + printf( "TIMA_Opt_Option_Load: Opt_Option_File_Load() failed (%d) !\n", status); + return( TIMAS_KO); + } + } + + + + /* Final command line loading */ + + if( ( status = Opt_Option_Env_Copy( TIMAG_Option_Tab, TIMAD_OPTION_ENV_CURRENT, TIMAD_OPTION_ENV_DEFAULT)) != TIMAS_OK) + { + printf( "TIMA_Opt_Option_Load: Opt_Option_Env_Copy() DEFAULT to CURRENT failed (%d) !\n", status); + return( TIMAS_KO); + } + + if( ( status = Opt_Option_Env_Copy( TIMAG_Option_Tab, TIMAD_OPTION_ENV_CURRENT, TIMAD_OPTION_ENV_CONFIG)) != TIMAS_OK) + { + printf( "TIMA_Opt_Option_Load: Opt_Option_Env_Copy() CONFIG to CURRENT failed (%d) !\n", status); + return( TIMAS_KO); + } + + if( ( status = Opt_Option_Env_Copy( TIMAG_Option_Tab, TIMAD_OPTION_ENV_CURRENT, TIMAD_OPTION_ENV_COMMAND)) != TIMAS_OK) + { + printf( "TIMA_Opt_Option_Load: Opt_Option_Env_Copy() COMMAND to CURRENT failed (%d) !\n", status); + return( TIMAS_KO); + } + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status TIMA_Opt_OptionValue_Print( FILE *Out, TIMAT_OptionValue *OptionValue_Ptr) +{ + switch( OptionValue_Ptr->Type) + { + case TIMAD_OPTION_VALUE_TYPE_UNKNOWN: + { + fprintf( Out, "Unknown Type"); + break; + } + + case TIMAD_OPTION_VALUE_TYPE_FLAG: + { + fprintf( Out, "%s", ( *OptionValue_Ptr->Data == TIMAD_UNKNOWN) ? "Unknown" : ( ( *OptionValue_Ptr->Data == TIMAD_TRUE) ? "ON" : ( ( *OptionValue_Ptr->Data == TIMAD_FALSE) ? "OFF" : "???"))); + break; + } + + case TIMAD_OPTION_VALUE_TYPE_LONG: + { + if( *(char *)OptionValue_Ptr->Data == TIMAD_UNKNOWN) + { + fprintf( Out, "%s", "Unknown"); + } + else + { + fprintf( Out, "%d", *(long *)OptionValue_Ptr->Data); + } + break; + } + + case TIMAD_OPTION_VALUE_TYPE_STRING: + { + fprintf( Out, "%s", ( *OptionValue_Ptr->Data == TIMAD_UNKNOWN) ? "Unknown" : OptionValue_Ptr->Data); + break; + } + + default: + { + fprintf( Out, "???"); + break; + } + } + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status TIMA_Opt_Option_Print( FILE *Out, TIMAT_Option *OptionStruct_Ptr) +{ + NDT_Status nd_status; + short i; + + + for( i = 1; TIMAG_Option_Tab[i].Arg_Number != 0; i++) + { + + if( TIMAG_Option_Tab[i].Switch_Off_Long[0] != '\0') + { + fprintf( Out, "-%s%*s--%s%*sSwitch On %s\n", + TIMAG_Option_Tab[i].Switch_On_Short, ( 3 + TIMAD_OPTION_SWITCH_SHORT_SIZE - strlen( TIMAG_Option_Tab[i].Switch_On_Short)), " ", + TIMAG_Option_Tab[i].Switch_On_Long, ( 3 + TIMAD_OPTION_SWITCH_LONG_SIZE - strlen( TIMAG_Option_Tab[i].Switch_On_Long) + 3 + TIMAD_OPTION_ARG_LABEL_SIZE), " ", + TIMAG_Option_Tab[i].Label); + + fprintf( Out, "-%s%*s--%s%*sSwitch Off %s%*s", + TIMAG_Option_Tab[i].Switch_Off_Short, ( 3 + TIMAD_OPTION_SWITCH_SHORT_SIZE - strlen( TIMAG_Option_Tab[i].Switch_Off_Short)), " ", + TIMAG_Option_Tab[i].Switch_Off_Long, ( 3 + TIMAD_OPTION_SWITCH_LONG_SIZE - strlen( TIMAG_Option_Tab[i].Switch_Off_Long) + 3 + TIMAD_OPTION_ARG_LABEL_SIZE), " ", + TIMAG_Option_Tab[i].Label, ( 3 + TIMAD_OPTION_LABEL_SIZE - strlen( TIMAG_Option_Tab[i].Label) - 11), " "); + } + else + { + fprintf( Out, "-%s%*s--%s%*s%s%*s%s%*s", + TIMAG_Option_Tab[i].Switch_Short, ( 3 + TIMAD_OPTION_SWITCH_SHORT_SIZE - strlen( TIMAG_Option_Tab[i].Switch_Short)), " ", + TIMAG_Option_Tab[i].Switch_Long, ( 3 + TIMAD_OPTION_SWITCH_LONG_SIZE - strlen( TIMAG_Option_Tab[i].Switch_Long)), " ", + TIMAG_Option_Tab[i].Arg_Label, ( 3 + TIMAD_OPTION_ARG_LABEL_SIZE - strlen( TIMAG_Option_Tab[i].Arg_Label)), " ", + TIMAG_Option_Tab[i].Label, ( 3 + TIMAD_OPTION_LABEL_SIZE - strlen( TIMAG_Option_Tab[i].Label)), " "); + } + + fprintf( Out, "Default: "); + + if( ( TIMAG_Option_Tab[i].Arg_Number <= 2) && ( TIMAG_Option_Tab[i].Arg_Type == TIMAD_OPTION_ARG_TYPE_MONO)) + { + fprintf( Out, "["); + TIMA_Opt_OptionValue_Print( Out, &TIMAG_Option_Tab[i].OptionValueData_Tab[TIMAD_OPTION_ENV_DEFAULT]); + fprintf( Out, "]\n"); + } + else + { + if( TIMAG_Option_Tab[i].OptionValueStruct_Tab[TIMAD_OPTION_ENV_DEFAULT]->Index_Tab[NDD_INDEX_PRIMARY].Node_Number >0) + { + if( ( nd_status = ND_DataStruct_Value_Print( Out, TIMAG_Option_Tab[i].OptionValueStruct_Tab[TIMAD_OPTION_ENV_DEFAULT], NDD_RECURSIVE_MODE_PARENT_CHILD, 2, 0)) != NDS_OK) + { + printf( "TIMA_Opt_Option_Print: ND_DataStruct_Value_Print() failed: (%d)...\n", nd_status); + return( TIMAS_KO); + } + + fprintf( Out, "\n"); + } + else + { + fprintf( Out, "[]\n"); + } + } + } + fprintf( Out, "\n"); + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status TIMA_Opt_Option_Dump( FILE *Out, TIMAT_Option *OptionStruct_Ptr) +{ + NDT_Status nd_status; + short i, j; + + + for( i = 1; TIMAG_Option_Tab[i].Arg_Number != 0; i++) + { + + if( TIMAG_Option_Tab[i].Switch_Off_Long[0] != '\0') + { + fprintf( Out, "Long On Switch: [--%s] Short On Switch: [-%s] Long Off Switch: [--%s] Short Off Switch: [-%s] ", + TIMAG_Option_Tab[i].Switch_On_Long, TIMAG_Option_Tab[i].Switch_On_Short, + TIMAG_Option_Tab[i].Switch_Off_Long, TIMAG_Option_Tab[i].Switch_Off_Short); + } + else + { + fprintf( Out, "Long Switch: [--%s] Short Switch: [-%s] ", + TIMAG_Option_Tab[i].Switch_Long, TIMAG_Option_Tab[i].Switch_Short); + } + + fprintf( Out, "Label: [%s] Arg Number: (%d) Arg Type: (%d) [%s]\nValue Type: ", + TIMAG_Option_Tab[i].Label, TIMAG_Option_Tab[i].Arg_Number, TIMAG_Option_Tab[i].Arg_Type, TIMA_OPTION_ARG_TYPE_ASCII_GET( TIMAG_Option_Tab[i].Arg_Type)); + + for( j = 0; j < TIMAG_Option_Tab[i].Arg_Number; j++) + { + fprintf( Out, "(%d) [%s] ", TIMAG_Option_Tab[i].Value_Type_Tab[j], TIMA_OPTION_VALUE_TYPE_ASCII_GET(TIMAG_Option_Tab[i].Value_Type_Tab[j])); + } + + fprintf( Out, "OptionValueData Flat Default: [%s]\n", ( TIMAG_Option_Tab[i].OptionValueData_Flat_Default[0] == (char)TIMAD_UNKNOWN) ? "Unknown" : TIMAG_Option_Tab[i].OptionValueData_Flat_Default); + fprintf( Out, "Value:"); + + if( TIMAG_Option_Tab[i].Arg_Type == TIMAD_OPTION_ARG_TYPE_MONO) + { + for( j = 0; j < TIMAD_OPTION_ENV_NUMBER; j++) + { + if( j != TIMAD_OPTION_ENV_UNKNOWN) + { + fprintf( Out, " %s: [", TIMA_OPTION_ENV_ASCII_GET( j)); + TIMA_Opt_OptionValue_Print( Out, &TIMAG_Option_Tab[i].OptionValueData_Tab[j]); + fprintf( Out, "]"); + } + } + + fprintf( Out, "\n"); + } + else + { + if( TIMAG_Option_Tab[i].Arg_Type == TIMAD_OPTION_ARG_TYPE_MULTI) + { + for( j = 0; j < TIMAD_OPTION_ENV_NUMBER; j++) + { + if( j != TIMAD_OPTION_ENV_UNKNOWN) + { + fprintf( Out, "\n %s:%*s", TIMA_OPTION_ENV_ASCII_GET( j), ( 10 - strlen(TIMA_OPTION_ENV_ASCII_GET( j))), " "); + + if( ( nd_status = ND_DataStruct_Value_Print( Out, TIMAG_Option_Tab[i].OptionValueStruct_Tab[j], NDD_RECURSIVE_MODE_PARENT_CHILD, 2, 0)) != NDS_OK) + { + printf( "TIMA_Opt_Option_Dump: ND_DataStruct_Value_Print() failed: (%d)...\n", nd_status); + return( TIMAS_KO); + } + } + } + } + } + + fprintf( Out, "\n"); + } + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status TIMA_Opt_OptionValue_Next( TIMAT_OptionValue **OptionValue_Next_Ptr_Ptr, TIMAT_OptionValue *OptionValue_Cur_Ptr, TIMAT_Option *Option_Ptr, short Env) +{ + NDT_Status nd_status; + NDT_Node *node_ptr; + + + if( OptionValue_Cur_Ptr == NULL) + { + if( ( nd_status = ND_Index_Node_First_Get( &node_ptr, Option_Ptr->OptionValueStruct_Tab[Env], NDD_INDEX_PRIMARY)) != NDS_OK) + { + node_ptr = NULL; +// return( TIMAS_KO); + } + } + else + { + if( ( nd_status = ND_Index_Node_Next_Get( &node_ptr, OptionValue_Cur_Ptr->Node)) != NDS_OK) + { + node_ptr = NULL; +// return( TIMAS_KO); + } + } + + if( node_ptr != NULL) + { + *OptionValue_Next_Ptr_Ptr = node_ptr->Value; + } + else + { + *OptionValue_Next_Ptr_Ptr = NULL; + } + + return( TIMAS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +TIMAT_Status TIMA_Opt_Obj_Status_Get( short *Status, short Option_Id_Enabled, short Option_Id_Disabled, short Env, short OptionValueData_Nb, TIMAT_OptionValueData *Data_Tab) +{ + TIMAT_Status status; + TIMAT_OptionValue *optionvalue_ptr = NULL; + short match, i; + + + do + { + for( i = 0, match = TIMAD_TRUE; i < OptionValueData_Nb; i++) + { + if( ( status = TIMA_Opt_OptionValue_Next( &optionvalue_ptr, optionvalue_ptr, &TIMAG_Option_Tab[Option_Id_Enabled], Env)) != TIMAS_OK) + { + printf( "TIMA_Opt_Obj_Status_Get: TIMA_Opt_OptionValue_Next() failed (%d)...\n", status); + return( TIMAS_KO); + } + + if( optionvalue_ptr == NULL) + { + i = OptionValueData_Nb; + } + else + { + if( ( match == TIMAD_TRUE) && ( strcmp( optionvalue_ptr->Data, Data_Tab[i]))) + { + match = TIMAD_FALSE; + } + } + } + } + while( ( optionvalue_ptr != NULL) && ( match != TIMAD_TRUE)); + + if( optionvalue_ptr == NULL) + { + do + { + for( i = 0, match = TIMAD_TRUE; i < OptionValueData_Nb; i++) + { + if( ( status = TIMA_Opt_OptionValue_Next( &optionvalue_ptr, optionvalue_ptr, &TIMAG_Option_Tab[Option_Id_Disabled], Env)) != TIMAS_OK) + { + printf( "TIMA_Opt_Obj_Status_Get: TIMA_Opt_OptionValue_Next() failed (%d)...\n", status); + return( TIMAS_KO); + } + + if( optionvalue_ptr == NULL) + { + i = OptionValueData_Nb; + } + else + { + if( ( match == TIMAD_TRUE) && ( strcmp( optionvalue_ptr->Data, Data_Tab[i]))) + { + match = TIMAD_FALSE; + } + } + } + } + while( ( optionvalue_ptr != NULL) && ( match != TIMAD_TRUE)); + + if( optionvalue_ptr == NULL) + { + *Status = TIMAD_TRUE; + } + else + { + *Status = TIMAD_FALSE; + } + } + else + { + *Status = TIMAD_TRUE; + } + + return(TIMAS_OK); +}