libnode/util/ndbench.c

/*---------------------------------------------------------------------------------*/
/* $RCSfile: ndbench.c,v $                                                         */
/*---------------------------------------------------------------------------------*/
/* $Revision: 2.9 $                                                                */
/* $Name:  $                                                        */
/* $Date: 2005/01/20 00:07:27 $                                                    */
/* $Author: agibert $                                                              */
/*---------------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------------*/
/* This file is part of LibNode                                                    */
/*                                                                                 */
/*    LibNode is free software; you can redistribute it and/or modify              */
/*    it under the terms of the GNU General Public Licence as published by         */
/*    the Free Software Foundation; either version 2 of the License, or            */
/*    (at your option) any later version.                                          */
/*                                                                                 */
/*    LibNode is distributed in the hope that it will be useful,                   */
/*    but WITHOUT ANY WARRANTY; without even the implied warranty of               */
/*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                */
/*    GNU Lesser General Public License for more details.                          */
/*                                                                                 */
/*    You should have received a copy of the GNU General Public License            */
/*    along with LibNode; if not, write to the Free Software                       */
/*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    */
/*---------------------------------------------------------------------------------*/





/*---------------------------------------------------------------------------------*/
/* Includes                                                                        */
/*---------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>



#ifdef _WIN32 
#   include <sys/timeb.h>
#else
#   include <sys/time.h>
#endif

#ifdef _LIBVER_SUPPORT
#   include <ver.h>
#endif





/*---------------------------------------------------------------------------------*/
/* Defines                                                                         */
/*---------------------------------------------------------------------------------*/

#ifdef _LIBVER_SUPPORT
VER_INFO_EXPORT( ndbench, "$Revision: 2.9 $", "$Name:  $", __FILE__, "$Author: agibert $");
#   define USAGE "Usage : %s [ --help | --version [-v] | --batch_run <batch_file_name>]\n"
#else
#   define USAGE "Usage : %s [ --help | --batch_run <batch_file_name>]\n"
#endif

#include <node.h>



#define QUIT                     0
#define LIB_OPEN                 1
#define LIB_CLOSE                2
#define DS_OPEN                  3
#define DS_CLOSE                 4
#define DS_FLUSH                 5
#define DS_CHECK                 6
#define DS_REORG                 7
#define DS_INFO_PRINT            8
#define DS_VALUE_ADD             9
#define DS_VALUE_REMOVE         10
#define DS_VALUE_PRINT          11
#define DS_VALUE_FIND           12
#define INDEX_LIST_OPEN         13
#define INDEX_TREE_OPEN         14
#define INDEX_CLOSE             15
#define INDEX_FLUSH             16
#define INDEX_CHECK             17
#define INDEX_LIST_SUBTYPE_SET  18
#define INDEX_LIST_TO_TREE      19
#define INDEX_TREE_SUBTYPE_SET  20
#define INDEX_TREE_TO_LIST      21
#define INDEX_REORG             22
#define INDEX_INFO_PRINT        23
#define INDEX_VALUE_PRINT       24
#define INDEX_VALUE_BREAK       25
#define INDEX_NODE_BREAK        26
#define BATCH_RUN               27

#define COMMAND_NB              28

#define INDEX_NB                32



#define DS_STATE_UNKNOWN  0
#define DS_STATE_OPENED   1
#define DS_STATE_CLOSED   2



#define ARG_SIZE          ( 32 + 1)



#define BUF_LEN            99
#define BUF_SIZE           (BUF_LEN + 1)





/*---------------------------------------------------------------------------------*/
/* Types                                                                           */
/*---------------------------------------------------------------------------------*/

typedef struct Command
{

	short           id;
	char            Name[25];
	char            FullName[64];
	short           DS_State;
	NDT_Index_Type  Index_Type;

} Command;

typedef char  Arg[32 + 1];



/* Mesure des temps d'ex<65>cution */

#ifdef _WIN32 

typedef struct
{
	double         sec;
	struct _timeb  start;
	struct _timeb  stop;
}  cpt;

#   define t_start(x)   { _ftime( &(x.start));}
#   define t_stop(x)    { _ftime( &(x.stop)); x.sec = (double)(x.stop.time) - (double)(x.start.time) + ((double)(x.stop.millitm) - (double)(x.start.millitm)) / 1000;}
#   define seed_get(x)  (int)( (x).start.time)

#else

typedef struct
{
	double          sec;
	struct timeval  start;
	struct timeval  stop;
}  cpt;

#   define t_start(x)   { gettimeofday( &((x).start), NULL);}
#   define t_stop(x)    { gettimeofday( &((x).stop), NULL); (x).sec = (double)((x).stop.tv_sec) - (double)((x).start.tv_sec) + ((double)((x).stop.tv_usec) - (double)((x).start.tv_usec)) / 1000000;}
#   define seed_get(x)  (int)( (x).start.tv_sec)

#endif

cpt t_exec;



/* D<>finition des valeurs attach<63>es aux noeuds de la structure */

typedef struct
{
	int    Id;
	char  *Nom;
} T_Module;



NDT_Index_Type  idx_type_tab[INDEX_NB];

NDT_Index_Type  idx_type_fifo          = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO;

NDT_Index_Type  idx_type_sorted_list   = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED;

NDT_Index_Type  idx_type_balanced_tree = NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED;





/*---------------------------------------------------------------------------------*/
/* Prototype                                                                       */
/*---------------------------------------------------------------------------------*/

NDT_Status  Module_Manager( NDT_Root  *, NDT_Index_Id, NDT_Node  *, NDT_Command, va_list);

void  Menu_Print( FILE  *, NDT_Root  *);
void  Command_Get( int  *, char  **, char  **, FILE  *, FILE  *, short);
void  Command_Exec_Begin_Print( FILE  *, int);
void  Command_Exec_End_Print( FILE  *, int, cpt, int);
void  Command_Index_Range_Get( FILE  *, int  *, int  *, char  *, FILE  *, int, char  *);
void  Command_Exec( NDT_Root  **, FILE  *, int, char  *, char  *, FILE  *);
void  Batch_Run( NDT_Root  **, FILE  *, FILE  *, short);





/*---------------------------------------------------------------------------------*/
/* Global Variable                                                                 */
/*---------------------------------------------------------------------------------*/

Command  Command_Tab[] =
{
    { QUIT,                   "Quit",                   "Quit",                             ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { LIB_OPEN,               "Lib_Open",               "Open Library",                     ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { LIB_CLOSE,              "Lib_Close",              "Close Library",                    ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_OPEN,                "DS_Open",                "Open DataStructure",               ( DS_STATE_CLOSED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_CLOSE,               "DS_Close",               "Close DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_FLUSH,               "DS_Flush",               "Flush DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_CHECK,               "DS_Check",               "Check DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_REORG,               "DS_Reorg",               "Reorg DataStructure",              ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_INFO_PRINT,          "DS_Info_Print",          "Print DataStructure Informations", ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_VALUE_ADD,           "DS_Value_Add",           "Add Values to DataStructure",      ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_VALUE_REMOVE,        "DS_Value_Remove",        "Remove Values from DataStructure", ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_VALUE_PRINT,         "DS_Value_Print",         "Print DataStructure Values",       ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { DS_VALUE_FIND,          "DS_Value_Find",          "Find Values in DataStructure",     ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_LIST_OPEN,        "Index_List_Open",        "Open List Index",                  ( DS_STATE_CLOSED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_TREE_OPEN,        "Index_Tree_Open",        "Open Tree Index",                  ( DS_STATE_CLOSED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_CLOSE,            "Index_Close",            "Close Index",                      ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_FLUSH,            "Index_Flush",            "Flush  Index",                     ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_CHECK,            "Index_Check",            "Check  Index",                     ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_LIST_SUBTYPE_SET, "Index_List_SubType_Set", "Set List SubType",                 ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST)},
    { INDEX_LIST_TO_TREE,     "Index_List_To_Tree",     "Convert List to Tree",             ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST)},
    { INDEX_TREE_SUBTYPE_SET, "Index_Tree_SubType_Set", "Set Tree SubType",                 ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_TREE)},
    { INDEX_TREE_TO_LIST,     "Index_Tree_To_List",     "Convert Tree to List",             ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_TREE)},
    { INDEX_REORG,            "Index_Reorg",            "Reorg Index",                      ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_INFO_PRINT,       "Index_Info_Print",       "Print Index Informations",         ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_VALUE_PRINT,      "Index_Value_Print",      "Print Index Values",               ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_VALUE_BREAK,      "Index_Value_Break",      "Break Index Value",                ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { INDEX_NODE_BREAK,       "Index_Node_Break",       "Break Index Node",                 ( DS_STATE_OPENED),                   ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)},
    { BATCH_RUN,              "Batch_Run",              "Run NDBench Bach",                 ( DS_STATE_OPENED | DS_STATE_CLOSED), ( NDD_INDEX_TYPE_LIST | NDD_INDEX_TYPE_TREE)}
};





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

NDT_Status  Module_Manager( 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: 2.9 $   $Name:  $   $Date: 2005/01/20 00:07:27 $   $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);
	      void          *Value_ptr          =         (void  *)va_arg( Args, void  *);
            */
            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);
            T_Module      **Module_Ptr_Ptr     =    (T_Module  **)va_arg( Args, T_Module  **);


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

                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, ...);
            */
            T_Module  **Module_Ptr_Ptr = (T_Module  **)va_arg( Args, T_Module  **);
            va_list     user_args      =      (va_list)va_arg( Args, va_list);
            char       *Nom            =      (char  *)va_arg( user_args, char  *);
            int         Id             =          (int)va_arg( user_args, int);


            Command_Name = "NDD_CMD_VALUE_ALLOC";

            if( ( *Module_Ptr_Ptr = (T_Module  *)malloc( sizeof(T_Module))) != NULL)
            {
                (*Module_Ptr_Ptr)->Nom = strdup(Nom);
                (*Module_Ptr_Ptr)->Id = Id;

                return( NDS_OK);
            }
            else
            {
                return( NDS_KO);
            }

        }

        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, ...);
            */
            T_Module  *Module_Ptr = (T_Module  *)va_arg( Args, T_Module  *);


            Command_Name = "NDD_CMD_VALUE_FREE";


            free( Module_Ptr->Nom);
            free( Module_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, ...);
            */
            T_Module  *Value1 = (T_Module  *)va_arg( Args, T_Module  *);
            T_Module  *Value2 = (T_Module  *)va_arg( Args, T_Module  *);


            Command_Name = "NDD_CMD_VALUE_COMP";

            if( ( Index_Id >= 0) && ( Index_Id < INDEX_NB))
            {
                int  rc;


                rc = Value1->Id - Value2->Id;

                if( rc < 0)
                {
                    return(NDS_LOWER);
                }
                else
                {
                    if( rc > 0)
                    {
                        return(NDS_GREATER);
                    }
                    else
                    {
                        return(NDS_EQUAL);
                    }
                }
            }
	    else
	    {
                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, ...);
            */


            Command_Name = "NDD_CMD_VALUE_ADD";

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

            T_Module             *Module_Ptr      = Node_Ptr->Value;


            Command_Name = "NDD_CMD_VALUE_PRINT";

            fprintf( Out, "Id=%d\tNom=\"%s\"\n", Module_Ptr->Id, Module_Ptr->Nom);

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

        }

        default:
        {
            printf( "Module_Manager() called with an undefined command %d\n", Command);
            return( NDS_ERRAPI);

        }
    }

    printf( "Module_Manager() called with command %d (%s)\n", Command, Command_Name);
    return( NDS_OK);
}





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

void  Menu_Print( FILE  *File_Output, NDT_Root  *DS_Ptr)
{
    short  i;
    char   headc;


    fprintf( File_Output, "\n-----------------------------------------------------------------------\nMenu :\n");

    for( i = 0; i < COMMAND_NB; i++)
    {
        if( ( DS_Ptr && ( Command_Tab[i].DS_State & DS_STATE_OPENED) && ( DS_Ptr->Index_Tab[0].Type & Command_Tab[i].Index_Type))
            || ( !DS_Ptr && ( Command_Tab[i].DS_State & DS_STATE_CLOSED)))
        {
            headc = '-';
        }
        else
        {
            headc = '*';
        }          
        
        fprintf( File_Output, "\t%c (%2d) [%s]%*s%s\n", headc, i, Command_Tab[i].Name, ( 25 - strlen(Command_Tab[i].Name)), " ", Command_Tab[i].FullName);
    }
}





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

void  Command_Get( int  *choice, char  **arg1, char  **arg2, FILE  *File_Output, FILE  *File_Input, short  Interactive_Flag)
{
    char   buf[100];
    char  *tmp_arg1, *tmp_arg2;


    do
    {
        if( Interactive_Flag)
        {
            fprintf( File_Output, "\nChoice ? ");
        }

        if( fgets( buf, BUF_LEN, File_Input) != NULL)
        {
            while( ( buf[ strlen( buf) - 1] == '\r') || ( buf[ strlen( buf) - 1] == '\n') || ( buf[ strlen( buf) - 1] == '\t') || ( buf[ strlen( buf) - 1] == ' '))
            {
                buf[ strlen( buf) - 1] = '\0';
            }

            if( isdigit( *buf))
            {
                *choice = atoi( buf);
            }
            else
            {
                for( *choice = 0; ( *choice < COMMAND_NB) && ( strncmp( buf, Command_Tab[*choice].Name, strlen(Command_Tab[*choice].Name))) ; (*choice)++);
            }

            if( ( *choice < 0) || ( *choice >= COMMAND_NB))
            {
                if( strlen( buf) != 0) fprintf( File_Output, "\nUndefined choice (%s) !\n",buf);

                *choice = -1;
                *arg1 = NULL;
                *arg2 = NULL;
            }
            else
            {
                if( ( tmp_arg1 = strstr( buf, " ")) != NULL)
                {
                    tmp_arg1++;

                    if( ( tmp_arg2 = strstr( tmp_arg1, " ")) != NULL)
                    {
                        *tmp_arg2 = '\0';
                        tmp_arg2++;

                        *arg2 = malloc( ARG_SIZE);
                        if( *arg2 != NULL) strcpy( *arg2, tmp_arg2);
                    }
                    else
                    {
                        *arg2 = NULL;
                    }

                    *arg1 = malloc( ARG_SIZE);
                    if( *arg1 != NULL) strcpy( *arg1, tmp_arg1);
                }
                else
                {
                    *arg1 = NULL;
                    *arg2 = NULL;
                }
            }
        }
        else
        {
            *choice = 0;
            *arg1 = NULL;
            *arg2 = NULL;
        }
    }
    while( *choice == -1);
}





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

void  Command_Exec_Begin_Print( FILE  *File_Output, int  Choice)
{
    fprintf( File_Output, "%s: %s...\n", Command_Tab[Choice].Name, Command_Tab[Choice].FullName);
    fflush( File_Output);
}





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

void  Command_Exec_End_Print( FILE  *File_Output, int  Choice, cpt  T_Exec, int  nb)
{
    if( nb == 1)
    {
	fprintf( File_Output, "%s: Completed in (%.4f) second !\n", Command_Tab[Choice].Name, T_Exec.sec);
    }
    else
    {
	fprintf( File_Output, "%s: Completed in (%.4f) second, (%.2f) per second !\n", Command_Tab[Choice].Name, T_Exec.sec, nb / T_Exec.sec);
    }
}





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

void  Command_Index_Range_Get( FILE  *File_Output, int  *Low, int  *High, char  *Arg, FILE  *File_Input, int  Choice, char  *Obj_Name)
{
    char   buf[100];
    char  *tmp;


    if( Arg == NULL)
    {
        fprintf( File_Output, "%s: %s range (?-?) : ", Command_Tab[Choice].Name, Obj_Name);
        fgets( buf, BUF_LEN, File_Input);

        Arg = buf;
    }

    tmp = strstr( Arg, "-");

    if( tmp != NULL)
    {
        *tmp = '\0';
        *Low = atoi( Arg);
        tmp++;
        *High = atoi( tmp);
  
        if( ( *High < *Low) || ( !strcmp( Obj_Name, "Index") && ( *High >= INDEX_NB)))
        {
            fprintf( File_Output, "%s: Invalit range (%d-%d) !\n", Command_Tab[Choice].Name, *Low, *High);
            *Low = *High = -1;
        }
    }
    else
    {
        fprintf( File_Output, "%s: Invalit range !\n", Command_Tab[Choice].Name);
        *Low = *High = -1;
    }
}





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

void  Command_Exec( NDT_Root  **DS_Ptr_Ptr, FILE  *File_Output, int  Choice, char  *Arg1, char  *Arg2, FILE  *File_Input)
{
    int             low, high, i, j, nb_removed, Nb_Detected, Nb_Corrected;
    T_Module        Ref_Module, *Module_Ptr;
    char            buf[BUF_SIZE];
    NDT_Index_Type  index_subtype;


    fprintf( File_Output, "\n");

    switch( Choice)
    {
        case QUIT:
        {
            break;
        }

        case LIB_OPEN:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

	    if( Arg1 == NULL)
	    {
		fprintf( File_Output, "Library_Open: Debug Mode ( 0:OFF | 1:ON) ? ");
		fgets( buf, BUF_LEN, File_Input);

		Arg1 = buf;
	    }

	    Choice = atoi( Arg1);

            t_start( t_exec);
            ND_Library_Open( Choice);
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case LIB_CLOSE:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            t_start( t_exec);
            ND_Library_Close();
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_OPEN:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

	    if( Arg1 == NULL)
	    {
		fprintf( File_Output, "DataStruct_Open: Symbol Lookup ( 0:OFF | 1:ON) ? ");
		fgets( buf, BUF_LEN, File_Input);

		Arg1 = buf;
	    }

	    Choice = atoi( Arg1);

            for( i = 0; i < INDEX_NB; i++)
            {
                idx_type_tab[i] = NDD_INDEX_STATUS_CLOSED;
            }

            t_start( t_exec);
	    if( Choice == 0)
	    {
		ND_DataStruct_Open( DS_Ptr_Ptr, INDEX_NB, idx_type_tab, "Module_Manager", Module_Manager, NULL, NULL, NULL, NULL, NDD_TRUE, NULL);
	    }
	    else
	    {
		ND_DataStruct_Open( DS_Ptr_Ptr, INDEX_NB, idx_type_tab, "Module_Manager",           NULL, NULL, NULL, NULL, NULL, NDD_TRUE, NULL);
	    }
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_CLOSE:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            t_start( t_exec);
            ND_DataStruct_Close( *DS_Ptr_Ptr);
            t_stop( t_exec);

            *DS_Ptr_Ptr = NULL;

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_FLUSH:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            t_start( t_exec);
            ND_DataStruct_Flush( *DS_Ptr_Ptr);
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_CHECK:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            Nb_Corrected = Nb_Detected = 0;

            t_start( t_exec);
            ND_DataStruct_Check( *DS_Ptr_Ptr, &Nb_Detected, &Nb_Corrected, File_Output);
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_REORG:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            t_start( t_exec);
            ND_DataStruct_Reorg( *DS_Ptr_Ptr);
            t_stop( t_exec);

            Command_Exec_End_Print( File_Output, Choice, t_exec, 1);
            break;
        }

        case DS_INFO_PRINT:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            ND_DataStruct_Info_Print( File_Output, *DS_Ptr_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);

            break;
        }

        case DS_VALUE_ADD:
        {
            int  order;


            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Value");

	    if( low != -1)
	    {
		if( Arg2 == NULL)
		{
		    fprintf( File_Output, "DS_Value_Add: Add order ( 0:croissant | 1:decroissant) ? ");
		    fgets( buf, BUF_LEN ,stdin);

		    Arg2 = buf;
		}

		order = atoi( Arg2);

		fprintf( File_Output, "DS_Value_Add: Adding from: (%d)   to: (%d)    order: (%d)...\n", low, high, order);
		fflush( File_Output);

		t_start( t_exec);

		if( order == 0)
		{
		    i = low;
		    j = high + 1;

		    while( i < j)
		    {
			if( ND_Value_Alloc( *DS_Ptr_Ptr, (void **)&Module_Ptr, "x", i) == NDS_OK)
			{
			    ND_DataStruct_Value_Add( *DS_Ptr_Ptr, Module_Ptr);
			}
			else
			{
			    fprintf( File_Output, "DS_Value_Add: Allocation Failled !\n");
			    break;
			}

			i++;
		    }
		}
		else
		{
		    i = high;
		    j = low - 1;

		    while( i > j)
		    {
			if( ND_Value_Alloc( *DS_Ptr_Ptr, (void **)&Module_Ptr, "x", i) == NDS_OK)
			{
			    ND_DataStruct_Value_Add( *DS_Ptr_Ptr, Module_Ptr);
			}
			else
			{
			    fprintf( File_Output, "DS_Value_Add: Allocation Failled !\n");
			    break;
			}

			i--;
		    }
		}

                t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case DS_VALUE_REMOVE:
        {
            int  order;
            nb_removed = 0;


            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Value");

	    if( low != -1)
	    {
		if( Arg2 == NULL)
		{
		    fprintf( File_Output, "\nDS_Value_Remove: Remove order (croissant=0 | decroissant=1) ? ");
		    fgets( buf, BUF_LEN, File_Input);

		    Arg2 = buf;
		}

		order = atoi( Arg2);

		t_start( t_exec);

		if( order == 0)
		{
		    i = low;
		    j = high + 1;

		    while( i < j)
		    {
			Ref_Module.Id = i;

			if( ( ND_DataStruct_Value_Find( (void **)&Module_Ptr, *DS_Ptr_Ptr, &Ref_Module) == NDS_OK) && ( Module_Ptr != NULL))
			{
			    if( ND_DataStruct_Value_Remove( *DS_Ptr_Ptr, (void **)&Module_Ptr) == NDS_OK)
			    {
				nb_removed++;
				ND_Value_Free( *DS_Ptr_Ptr, Module_Ptr);
			    }
			}

			i++;
		    }
		}
		else
		{
		    i = high;
		    j = low - 1;
		    t_start( t_exec);

		    while( i > j)
		    {
			Ref_Module.Id = i;

			if( ( ND_DataStruct_Value_Find( (void **)&Module_Ptr, *DS_Ptr_Ptr, &Ref_Module) == NDS_OK) && ( Module_Ptr != NULL))
			{
			    if( ND_DataStruct_Value_Remove( *DS_Ptr_Ptr, (void **)&Module_Ptr) == NDS_OK)
			    {
				nb_removed++;
				ND_Value_Free( *DS_Ptr_Ptr, Module_Ptr);        
			    }
			}

			i--;
		    }
		}

		t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case DS_VALUE_PRINT:
        {
            Command_Exec_Begin_Print( File_Output, Choice);

            ND_DataStruct_Value_Print( File_Output, *DS_Ptr_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);
            break;
        }

        case DS_VALUE_FIND:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Search");

	    if( low != -1)
	    {
		fprintf( File_Output, "DS_Value_Find: from: (%d)   to: (%d)...\n", low, high);
		fflush( File_Output);

		i = low;
		j = high + 1;

		t_start( t_exec);

		while( i < j)
		{
		    Ref_Module.Id = low + (int)( (double)( high - low) * rand() / ( RAND_MAX + 1.0));
		    ND_DataStruct_Value_Find( (void *)&Module_Ptr, *DS_Ptr_Ptr, &Ref_Module);
		    i++;
		}

		t_stop (t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case INDEX_LIST_OPEN:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {
		fprintf( File_Output, "Index_List_Open: Opening a FIFO List from: (%d)   to: (%d)...\n", low, high);
		fflush( File_Output);

		t_start( t_exec);

		for( i  = low; i <= high; i++)
		{
		    ND_Index_Open( *DS_Ptr_Ptr, (NDT_Index_Id)i, idx_type_fifo);
		}

		t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case INDEX_TREE_OPEN:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {

                fprintf( File_Output, "Index_Tree_Open: Opening a balanced Tree from: (%d)   to: (%d)...\n", low, high);
                fflush( File_Output);

                t_start( t_exec);

                for( i  = low; i <= high; i++)
		{
                    ND_Index_Open( *DS_Ptr_Ptr, (NDT_Index_Id)i, idx_type_balanced_tree);
		}

                t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case INDEX_CLOSE:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {

                fprintf( File_Output, "Index_Close: Closing index from: (%d)   to: (%d)...\n", low, high);
                fflush( File_Output);

                t_start( t_exec);

                for( i  = high; i >= low; i--)
                {
                    ND_Index_Close( *DS_Ptr_Ptr, (NDT_Index_Id)i);
      	        }

                t_stop( t_exec);

                Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
            }

            break;
        }

        case INDEX_LIST_SUBTYPE_SET:
        {
	    int subtype;


            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {
                if( Arg2 == NULL)
		{
		    fprintf( File_Output, "Index_List_SubType_Set: List SubType ( 0:FIFO | 1:LIFO | 2:Sorted) ? ");
		    fgets( buf, BUF_LEN, File_Input);

		    Arg2 = buf;
		}

		subtype = atoi( Arg2);

                switch( subtype)
                {
                    case 0:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_FIFO;
                        break;
                    }

                    case 1:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_FILO;
                        break;
                    }

                    case 2:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_SORTED;
                        break;
                    }

                    default:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_UNKNOWN;
                        printf ("Index_List_SubType_Set: Invalid selection (%d) !\n", subtype);
                        break;
                    }
                }

		if( index_subtype != NDD_INDEX_SUBTYPE_UNKNOWN)
		{
		    fprintf( File_Output, "Index_List_SubType_Set: Setting List SubType to: (%d) (%s) !\n", index_subtype, ND_INDEX_SUBTYPE_VALUE_ASCII_GET( index_subtype));

		    t_start( t_exec);

		    for( i  = low; i <= high; i++)
		    {
			if( ND_INDEX_TYPE_LIST_IS( *DS_Ptr_Ptr, i))
			{
			    (*DS_Ptr_Ptr)->Index_Tab[i].Type = ( (*DS_Ptr_Ptr)->Index_Tab[i].Type & NDD_INDEX_SUBTYPE_RMSK) | index_subtype;
			}
			else
			{
			    fprintf( File_Output, "Index_List_SubType_Set: Error: index (%d) is not a List !\n", i);
			}
		    }

		    t_stop( t_exec);

		    Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
		}
	    }

	    break;
        }

        case INDEX_TREE_SUBTYPE_SET:
        {
	    int subtype;


            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {
		if( Arg2 == NULL)
		{
		    fprintf( File_Output, "Index_Tree_SubType_Set: Tree SubType (0:UnBalanced | 1:Balanced) ? ");
		    fgets( buf, BUF_LEN, stdin);

		    Arg2 = buf;
		}

		subtype = atoi( Arg2);

                switch( subtype)
                {
                    case 0:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_UNBALANCED;
                        break;
                    }

                    case 1:
                    {
                        index_subtype = NDD_INDEX_SUBTYPE_BALANCED;
                        break;
                    }

                    default:
                    {
			index_subtype = NDD_INDEX_SUBTYPE_UNKNOWN;
                        printf ("Index_Tree_SubType_Set: Invalid selection (%d)!\n", subtype);
                        break;
                    }
		}

		if( index_subtype != NDD_INDEX_SUBTYPE_UNKNOWN)
		{
 
		    t_start( t_exec);

		    for( i  = low; i <= high; i++)
		    {
			if( ND_INDEX_TYPE_TREE_IS( *DS_Ptr_Ptr, i))
			{
			    (*DS_Ptr_Ptr)->Index_Tab[i].Type = ( (*DS_Ptr_Ptr)->Index_Tab[i].Type & NDD_INDEX_SUBTYPE_RMSK) | index_subtype;
			}
			else
			{
			    fprintf( File_Output, "Index_Tree_SubType_Set: Error: index (%d) is not a Tree !\n", i);
			}
		    }

		    t_stop( t_exec);

		    Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
		}
	    }

	    break;
        }

        case INDEX_REORG:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {
		t_start( t_exec);

		for( i  = low; i <= high; i++)
		{
		    fprintf( File_Output, "Index_Reorg: Reorganizing index (%d)...\n", i);
		    fflush( File_Output);

		    ND_Index_Reorg( *DS_Ptr_Ptr, (NDT_Index_Id)i);
		}

		t_stop( t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

	    break;
        }

        case INDEX_TREE_TO_LIST:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {
                t_start( t_exec);

                for( i  = low; i <= high; i++)
		{
                    fprintf( File_Output, "Index_Tree_To_List: Converting Index (%d)...\n", i);
                    fflush( File_Output);

                    ND_Index_Convert( *DS_Ptr_Ptr, (NDT_Index_Id)i, idx_type_sorted_list);
                }

                t_stop (t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case INDEX_LIST_TO_TREE:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {
                t_start( t_exec);

                for( i  = low; i <= high; i++)
		{
                    fprintf( File_Output, "Index_List_To_Tree: Converting Index (%d)...\n", i);
                    fflush( File_Output);

                    ND_Index_Convert( *DS_Ptr_Ptr, (NDT_Index_Id)i, idx_type_balanced_tree);
                }

                t_stop (t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case INDEX_INFO_PRINT:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {
                fprintf( File_Output, "Index_Info_Print: Printing index from: (%d)   to: (%d)...\n", low, high);
                fflush( File_Output);

                for( i  = low; i <= high; i++)
      	        {
		    ND_Index_Info_Print( File_Output, *DS_Ptr_Ptr, (NDT_Index_Id)i, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);
                }
	    }

            break;
        }

        case INDEX_VALUE_PRINT:
        {
            fprintf( File_Output, "DS_Value_Print:\n");
            fflush( File_Output);

            ND_DataStruct_Value_Print( File_Output, *DS_Ptr_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 99, 0);
            break;
        }

        case INDEX_VALUE_BREAK:
        {
	    int        position;
	    NDT_Node  *node_ptr;


            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {
		if( Arg2 == NULL)
		{
		    fprintf( File_Output, "Index_Value_Break: Value position (0:Head | 1:Tail | 2:Random) ? ");
		    fgets( buf, BUF_LEN, stdin);

		    Arg2 = buf;
		}

		position = atoi( Arg2);

                fprintf( File_Output, "Index_Value_Break: Breaking %s values from index : (%d)   to: (%d)...\n",
			 ( position == 0 ) ? "Head" : ( ( position == 1) ? "Tail" : "Random"),
			 low, high);
                fflush( File_Output);

                t_start( t_exec);

                fprintf( File_Output, "Index_Value_Break: Breaking value of nodes: ");
                fflush( File_Output);

                for( i  = low; i <= high; i++)
      	        {
		    switch( position)
		    {
			case 0:
			{
			    node_ptr  =(*DS_Ptr_Ptr)->Index_Tab[i].Head;
			    break;
			}

			case 1:
			{
			    node_ptr=(*DS_Ptr_Ptr)->Index_Tab[i].Tail;
			    break;
			}

			case 2:
			{
			    j = (int)( (double)( (*DS_Ptr_Ptr)->Index_Tab[i].Node_Number) * rand() / ( RAND_MAX + 1.0));

			    for( node_ptr = (*DS_Ptr_Ptr)->Index_Tab[i].Head; j > 0; j--)
			    {
				node_ptr = node_ptr->Right;
			    }

			    break;
			}
		    }

		    fprintf( File_Output, "0x(%x)", node_ptr);
		    fflush( File_Output);

		    node_ptr->Value = (void  *)-1;
                }

                t_stop (t_exec);

		fprintf( File_Output, "\n");
		fflush( File_Output);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case INDEX_NODE_BREAK:
        {

            break;
        }

        case INDEX_CHECK:
        {
            Command_Index_Range_Get( File_Output, &low, &high, Arg1, File_Input, Choice, "Index");

            if( low != -1)
            {
                t_start( t_exec);

                for( i  = low; i <= high; i++)
		{
                    fprintf( File_Output, "Index_Check: Checking Index (%d)...\n", i);
                    fprintf( File_Output, "Index_Check: ");
                    fflush( File_Output);

		    Nb_Corrected = Nb_Detected = 0;
		    ND_Index_Check( *DS_Ptr_Ptr, (NDT_Index_Id)i, &Nb_Detected, &Nb_Corrected, File_Output);
                }

                t_stop (t_exec);

		Command_Exec_End_Print( File_Output, Choice, t_exec, high - low);
	    }

            break;
        }

        case BATCH_RUN:
        {
            FILE  *file_input;


            if( Arg1 == NULL)
            {
                fprintf( File_Output, "Batch_Run: Batch file name ? ");

                fgets( buf, BUF_LEN, stdin);
                buf[ strlen( buf) - 1] = '\0';
                Arg1 = buf;
            }

            file_input = fopen( Arg1, "r");

            if( file_input == NULL)
            {
                fprintf( File_Output, "Batch_Run: Can't open file (%s)!\n", Arg1);
            }
            else
            {
                fprintf( File_Output, "\n\n--------------------------------------------------------------------------------\n");
                fprintf( File_Output, "Batch_Run: Starting execution (%s)...\n", Arg1);
                Batch_Run( DS_Ptr_Ptr, File_Output, file_input, 0);
                fprintf( File_Output, "\n");
                fprintf( File_Output, "Batch_Run: Ending execution (%s)...\n", Arg1);

		fclose( file_input);
            }

            break;
        }

        default:
        {
            fprintf( File_Output, "\nUndefined command (%d) !\n", Choice);
        }
    }
}





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

void  Batch_Run( NDT_Root  **DS_Ptr_Ptr, FILE  *File_Output, FILE  *File_Input, short  Interactive_Flag)
{
    int    choice;
    char  *arg1, *arg2;


    do
    {
        if( Interactive_Flag)
        {
            Menu_Print( File_Output, *DS_Ptr_Ptr);
        }

        Command_Get( &choice, &arg1, &arg2, File_Output, File_Input, Interactive_Flag);

        if( ( choice != QUIT) && ( choice != -1))
        {
            Command_Exec( DS_Ptr_Ptr, File_Output, choice, arg1, arg2, File_Input);
        }

	if( arg1 != NULL) free( arg1);
	if( arg2 != NULL) free( arg2);
    }
    while( choice != QUIT);
}





/*---------------------------------------------------------------------------------*/
/*                                                                                 */
/*---------------------------------------------------------------------------------*/

int  main( int  argc, char  **argv)
{
    NDT_Root  *ds_ptr = NULL;


    /* Init Random numbers... */

    t_start( t_exec);
    t_stop( t_exec);
    srand( seed_get(t_exec));



    /* Args Parsing */

    if( argc >= 2)
    {
        if( !strcmp( argv[1], "--help"))
        {
            fprintf( stderr, USAGE, argv[0]);
            return( 1);
        }
#ifdef _LIBVER_SUPPORT
        else if( !strcmp( argv[1], "--version"))
        {
            if( argc >= 3 && !strcmp( argv[2], "-v"))
            {
                return( VER_Object_Print( stdout, VERD_VERBOSE));
            }
            else
            {
	        return( VER_Object_Print( stdout, VERD_MINIMAL));
            }
        }
#endif
        else if( !strcmp( argv[1], "--batch_run"))
        {
            /* Batch Mode */

            Command_Exec( &ds_ptr, stdout, BATCH_RUN, argv[2], NULL, stdin);

            return( 0);
        }
        else
        {
            fprintf( stderr, USAGE, argv[0]);
            return( -1);
        }
    }



    /* Interactive Mode */

    Batch_Run( &ds_ptr, stdout, stdin, 1);

    return( 0);
}