Program: gdcm
Module: $RCSfile: gdcmArgMgr.cxx,v $
Language: C++
- Date: $Date: 2005/06/06 12:37:58 $
- Version: $Revision: 1.1 $
+ Date: $Date: 2007/05/23 14:18:07 $
+ Version: $Revision: 1.24 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include <ctype.h>
#include <string.h> // For strlen
+// No strcasecmp in WIN32 world, but stricmp
+// http://www.opengroup.org/onlinepubs/007908799/xsh/strcasecmp.html
+#ifdef _WIN32
+#define strcasecmp stricmp
+#endif
+
#include <string.h> // For strtok and strlen
#include <stdlib.h> // For strtol and strtod
#include "gdcmArgMgr.h"
-#define ARG_DEFAULT_PARAMOUT "fileout.par"
-#define ARG_DEFAULT_LOGFILE "gdcm.log"
-
-
-namespace gdcm
+namespace GDCM_NAME_SPACE
{
//-------------------------------------------------------------------------
// Constructor / Destructor
* @param argc arguments count, as passed to main()
* @param argv pointers array on the arguments passed to main()
*/
- ArgMgr::ArgMgr(int argc, char *argv[])
+ ArgMgr::ArgMgr(int argc, char **argv)
{
int i;
int nblettre;
}
}
- /* Fills an array with the alreadu used parameters ****/
+ /* Fills an array with the already used parameters ****/
ArgUsed = (char *)calloc (1, ArgCount );
/* Builds the full string with all the parameters **************/
}
/* Set labels to upper-case (labels are not case sensitive ) *********/
+ //char *secu;
for ( i=0; i<ArgCount; i++)
+ {
+ //secu = ArgLab[i];
ArgLab[i] = Majuscule ( ArgLab[i] ) ;
+ //free (secu); //we still need it in the caller pgm.
+ }
/* Standard arguments are managed by ArgStdArgs **********************/
ArgStdArgs();
ArgMgr::~ArgMgr()
{
for(int i=0;i<ArgCount;i++)
- if(ArgLab[i])
+ if ( ArgLab[i] )
free(ArgLab[i]);
- if(ArgUsed)
+ if ( ArgUsed )
free(ArgUsed);
- if(Appel)
+ if ( Appel )
free(Appel);
}
/**
* \brief checks if a parameter exists in the command line
- * @param searchParam name of the searched parameter label
- * @return true if parameter 'label' exists
- * Actually, it returns 0 if label is not found
+ * @param param label name
+ * @return 0 if label is not found
* else, returns the number of the spot it was found last time.
*/
-int ArgMgr::ArgMgrDefined( char *searchParam )
+int ArgMgr::ArgMgrDefined( const char *param )
{
- int i, trouve ;
+ int i;
+ bool trouve;
char *temp;
- temp = Majuscule ( searchParam ) ;
- for ( trouve = false, i = ArgCount-1; i>0; i-- )
+ temp = Majuscule ( param ) ;
+ for ( i = ArgCount-1; i>0; i-- )
{
- trouve = ! strcmp( ArgLab[i], temp ) ;
+ trouve = ( strcmp( ArgLab[i], temp )==0 ) ;
if ( trouve )
{
+ free (temp);
ArgUsed[i] = true ;
for ( int j=1; j<i; j++)
{
if ( (!ArgUsed[j])&&(!strcmp(ArgLab[i],ArgLab[j])) )
- ArgUsed[j] = true ;
+ ArgUsed[j] = i ;
}
return i ;
- }
+ }
}
- return false ;
+ free (temp);
+ return 0 ;
}
/**
* \brief Gets the parameter value, read on the command line
* @param param name of the searched parameter label
- * @return Value, as a characters string, of the parameter
+ * @return Value, as a char array, of the parameter
* whose label is given.
*/
-char *ArgMgr::ArgMgrValue ( char *param )
+char *ArgMgr::ArgMgrValue ( const char *param )
{
int trouve ;
if ( (trouve = ArgMgrDefined ( param )) != false )
/**
* \brief Search for the first not yet used label
- * @return Pointer to a char array holding the first non used label
+ * @return Pointer to the char array holding the first non used label
*/
-char *ArgMgr::ArgMgrUnused ( )
+const char *ArgMgr::ArgMgrUnused ( )
{
int i ;
for ( i=ArgCount-1; i>0; i-- )
*/
int ArgMgr::ArgMgrPrintUnusedLabels ()
{
- char *label;
+ const char *label;
int i=0;
while ( (label=ArgMgrUnused())!=0 )
{
/**
* \brief Prints program usage
- * @param usage array of pointers to the documentation lines
- * of the program.
+ * @param usage array of pointers to the documentation lines of the program.
* @return exception code
*/
-int ArgMgr::ArgMgrUsage(char **usage_text )
+int ArgMgr::ArgMgrUsage(const char **usage )
{
- while ( *usage_text )
- std::cout << std::endl << *(usage_text++);
+ while ( *usage )
+ std::cout << std::endl << *(usage++);
std::cout << std::endl;
return (0);
}
-
/**
* \brief Forget it, right now ...
- * sauvegarde une chaine de caract. dans un fichier de parameters
- * Le nom du fichier est celui specifie sur la ligne
- * d'appel par : PARAMOUT=???
- * ou, par defaut, celui donne par ARG_DEFAULT_PARAMOUT
- * @param param Chaine de caractere definissant le parameter:
+ * Saves a char. array in a parameter file
+ * whose name is given on command line by : PARAMOUT=???
+ * or, as a default, by ARG_DEFAULT_PARAMOUT
+ * @param param char. array that defines the parameter
* @return Entier correspondant au rang dans la liste de labels
*/
-int ArgMgr::ArgMgrSave ( char *param )
+int ArgMgr::ArgMgrSave ( const char *param )
{
static int deja = 0;
FILE *fd;
if ( *ArgParamOut == '\0' )
return 0;
- if(deja)
+ if ( deja )
{
fd = fopen ( ArgParamOut, "a+" );
}
/**
* \brief Gets an int value passed as an argument to a program
* (use default value if not found)
- * EXEMPLE: int dimx = ArgMgrGetInt ( "DIMX", 256 );
- * @param label parameter label
+ * EXAMPLE: int dimx = ArgMgrGetInt ( "DIMX", 256 );
+ * @param label label name
* @param defaultVal default value
* @return parameter value
*/
-int ArgMgr::ArgMgrGetInt(char *label, int defaultVal)
+int ArgMgr::ArgMgrGetInt(const char *label, int defaultVal)
{
return ( (ArgMgrDefined(label))
? (atoi(ArgMgrValue(label)))
/**
* \brief Gets a float value passed as an argument to a program
* (use default value if not found)
- * EXEMPLE: float scale = ArgMgrGetFloat ( "SCALE", 0.33 );
- * @param label parameter label
+ * EXAMPLE: float scale = ArgMgrGetFloat ( "SCALE", 0.33 );
+ * @param param label name
* @param defaultVal default value
* @return parameter value
*/
-float ArgMgr::ArgMgrGetFloat(char *label, float defaultVal)
+float ArgMgr::ArgMgrGetFloat(const char *param, float defaultVal)
{
- return ( (ArgMgrDefined(label))
- ? (atof(ArgMgrValue(label)))
+ return ( (ArgMgrDefined(param))
+ ? ((float)atof(ArgMgrValue(param)))
: (defaultVal) );
}
/**
* \brief Gets a 'string' value passed as an argument to a program
* (use default value if not found)
- * @param label parameter label
+ * EXAMPLE : char *imageName = ArgMgrGetString( "NAME", "test.dcm" );
+ * @param param label name
* @param defaultVal default value
* @return parameter value
*/
-char *ArgMgr::ArgMgrGetString(char *label, char *defaultVal)
+const char *ArgMgr::ArgMgrGetString(const char *param, const char *defaultVal)
{
- return ( (ArgMgrDefined(label))
- ? (ArgMgrValue(label))
+ return ( (ArgMgrDefined(param))
+ ? (ArgMgrValue(param))
: (defaultVal) );
}
/**
- * \brief Gets a value amongst a set od values
+ * \brief Gets a value amongst a set of values
* (use default value if not found)
- * EXEMPLE: int nlab = ArgMgrGetLabel("CONFIRM","NO\\YES", 0);
- * @param label parameter label
- * @param liste character Chain describing the varous values.
+ * EXAMPLE: int nlab = ArgMgrGetLabel("CONFIRM","NO\\YES", 0);
+ * @param param label name
+ * @param liste character Chain describing the various values.
* Value are separated by '\\'.
* Not case sensitive.
* @param val number of default value
* @return int : range of value amongst the values list
*/
-int ArgMgr::ArgMgrGetLabel (char *label, char *liste, int val )
+int ArgMgr::ArgMgrGetLabel (const char *param, const char *liste, int val )
{
char *lab;
- char *vallab;
+ const char *vallab;
int i = 1;
char *tmp;
tmp = (char *) malloc(strlen(liste)+1);
strcpy(tmp,liste);
- if ( (vallab = ArgMgrGetString(label,(char *)NULL)) != 0 )
+ if ( (vallab = ArgMgrGetString(param,(const char *)NULL)) != 0 )
{
for ( lab = strtok (tmp,"\\");
lab != 0;
lab = strtok(0L,"\\"), i++ )
{
- if ( strcmp(maj(lab),maj(vallab))==0)
+ // strcmp ignoring case
+ if( strcasecmp(lab, vallab) == 0)
return i;
}
val=0;
}
/**
- * \brief Lecture d'un arg.de type label parmi un ensemble de labels
- * EXEMPLE: int nlab = ArgMgrWantLabel("CONFIRM","NO\\YES", usage);
- * @param label Parameter label
- * @param liste Chaine de caracteres decrivant les differents labels.
- * Chaque label est separe par un '\\'.
- * Aucune difference n'est faite entre maj./min.
+ * \brief Demands a value amongst a set of values (abort if not found)
+ * EXaMPLE: int nlab = ArgMgrWantLabel("CONFIRM","NO\\YES", usage);
+ * @param param label name
+ * @param liste character Chain describing the various values.
+ * Labels are separated by '\\'.
+ * No case sensitive.
+ * WARNING this will be changed (not const)
* @param usage Usage program (displayed if label not found)
- * @return Entier correspondant au rang dans la liste de labels
+ * @return int : range of value amongst the values list
*/
-int ArgMgr::ArgMgrWantLabel (char *label, char *liste, char *usage[] )
+int ArgMgr::ArgMgrWantLabel (const char *param, char *liste, const char **usage )
{
char *lab;
- char *vallab;
+ const char *vallab;
int i = 1;
- if ( (vallab = ArgMgrGetString(label,0)) != 0 )
+ if ( (vallab = ArgMgrGetString(param,0)) != 0 )
{
for ( lab = strtok (liste,"\\"); lab != 0; lab = strtok(0L,"\\"), i++ )
- if ( strcmp(maj(lab),maj(vallab))==0)
+ if ( strcasecmp(lab,vallab)==0)
return i;
return 0;
}
/**
* \brief Demands an int value passed as an argument to a program
* If not found usage is displayed and the prog aborted
- * EXEMPLE: int dimx = ArgMgrWantInt ( "DIMX", usage );
- * @param label Parameter label
+ * EXAMPLE: int dimx = ArgMgrWantInt ( "DIMX", usage );
+ * @param label label name
* @param usage Usage program (displayed if label not found)
* @return parameter value
*/
-int ArgMgr::ArgMgrWantInt (char *label, char **usage)
+int ArgMgr::ArgMgrWantInt (const char *label, const char **usage)
{
return ( (ArgMgrDefined(label) )
? (atoi(ArgMgrValue(label) ) )
/**
* \brief Demands a float value passed as an argument to a program
* If not found usage is displayed and the prog aborted
- * EXEMPLE: float scale = ArgMgrWantFloat ( "SCALE", usage );
- * @param label Parameter label
+ * EXAMPLE: float scale = ArgMgrWantFloat ( "SCALE", usage );
+ * @param label label name
* @param usage Usage program (displayed if label not found)
* @return parameter value
*/
-float ArgMgr::ArgMgrWantFloat (char *label, char **usage)
+float ArgMgr::ArgMgrWantFloat (const char *label, const char **usage)
{
return ( (ArgMgrDefined(label) )
- ? (atof(ArgMgrValue(label) ) )
- : (ArgMgrUsage(usage),1.0) );
+ ? ((float)atof(ArgMgrValue(label) ) )
+ : (ArgMgrUsage(usage),(float)1.0) );
}
/**
* \brief Demands a 'string' value passed as an argument to a program
* If not found usage is displayed and the prog aborted
- * EXEMPLE: char *code = ArgMgrWantString ( "CODE", usage );
+ * EXAMPLE: char *code = ArgMgrWantString ( "CODE", usage );
* @param label Parameter label
* @param usage Usage program (displayed if label not found)
* @return parameter value
*/
-char *ArgMgr::ArgMgrWantString(char *label, char **usage)
+char *ArgMgr::ArgMgrWantString(const char *label, const char **usage)
{
return ( (ArgMgrDefined(label) )
? (ArgMgrValue(label) )
}
/**
- * \brief decodage des elements d'un argument 'liste de STRING' de lgr qcq
- * @param label pointer vers le label de la liste
- * @param number taille de la liste trouvee
- * @return Pointer vers le tableau de lgr 'taille'
- * Pointer NULL si erreur
+ * \brief decodes and returns an array of 'STRING'
+ * EXAMPLE: char **codes = ArgMgrGetListOfString ( "CODES", &nbOfCodes );
+ * @param label label name
+ * @param number nb of found 'STRINGs'
+ * @return Pointer to the 'STRING' array; NULL if error
*/
-char **ArgMgr::ArgMgrGetListOfString ( char *label, int *nbElem )
+char **ArgMgr::ArgMgrGetListOfString ( const char *label, int *number )
{
int taille;
char *value = ArgMgrValue(label);
char **elem;
char *chainecur;
if (!value)
+ {
+ *number = 0;
return 0;
- *nbElem = IdStrCountChar(value,',')+1; /* nb Elements = nb Commas +1 */
- taille = *nbElem;
+ }
+ *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Commas +1 */
+ taille = *number;
liste = (char **) malloc (sizeof(char*) * taille + strlen(value)+1);
if ( !liste )
return 0;
}
/**
- * \brief decodage des elements d'un argument 'liste diINTEGER' de lgr quelconque
- * @param label pointer vers le label de la liste
- * @param number taille de la liste trouvee
- * @return Pointer vers le tableau de lgr 'taille'
- * Pointer NULL si erreur
+ * \brief decodes and returns an array of 'INT'
+ * EXAMPLE: int *points = ArgMgrGetListOfInt ( "POINTS", &nbOfPoints );
+ * @param label label name
+ * @param number nb of found INT
+ * @return Pointer to the INT array; NULL if error
*/
-int *ArgMgr::ArgMgrGetListOfInt ( char *label, int *number )
+int *ArgMgr::ArgMgrGetListOfInt ( const char *label, int *number )
{
char *value = ArgMgrValue(label);
int *liste;
int *elem;
int taille;
if (!value)
+ {
+ *number = 0;
return 0;
- *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Commas +1 */
+ }
+ *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Commas +1 */
taille= *number;
liste = (int *) calloc (1,sizeof(int)*taille );
if ( !liste )
return 0;
elem = liste;
- *number = 1;
+ //*number = 1;
while ( taille>0 )
{
}
/**
- * \brief decodage des elements d'un argument 'liste de FLOAT' de lgr qcq
- * @param label pointer vers le label de la liste
- * @param number taille de la liste trouvee
- * @return Pointer vers le tableau de lgr 'taille'
- * NULL if error
+ * \brief decodes and returns an array of 'FLOAT'
+ * @param label label name
+ * @param number number of found FLOATs
+ * @return Pointer to the FLOAT array; NULL if error
*/
-float *ArgMgr::ArgMgrGetListOfFloat ( char *label, int *number )
+float *ArgMgr::ArgMgrGetListOfFloat ( const char *label, int *number )
{
char *value = ArgMgrValue(label);
float *liste;
taille= *number;
liste = (float *) calloc (1,sizeof(float)*taille );
if ( !liste )
+ {
+ *number = 0;
return 0;
+ }
elem = liste;
- *number = 1;
+ //*number = 1;
while ( taille>0 )
{
return liste;
}
+/**
+ * \brief decodes and returns an array of 'INT pairs', passed in decimal
+ * @param param label name
+ * @param number nb of found pairs
+ * @return pointer to the array of 'INT pairs'; NULL if fail
+ */
+int *ArgMgr::ArgMgrGetIntEnum ( const char *param, int *number )
+{
+ char *value = ArgMgrValue(param);
+ int *liste;
+ if (!value)
+ {
+ *number = 0;
+ return 0;
+ }
+ liste = IdStrIntEnum(value, number);
+ return liste;
+}
+
+/**
+ * \brief decodes and returns an array of 'INT16 pairs', passed in hexadecimal
+ * @param param label name
+ * @param number nb of found pairs
+ * @return pointer to the array of 'INT16 pairs'; NULL if fail
+ */
+uint16_t *ArgMgr::ArgMgrGetXInt16Enum ( const char *param, int *number )
+{
+ char *value = ArgMgrValue(param);
+ uint16_t *liste;
+ if (!value)
+ {
+ *number = 0;
+ return 0;
+ }
+ liste = IdStrXInt16Enum(value, number);
+ return liste;
+}
+/**
+ * \brief decodes and returns an array of 'FLOAT pairs'
+ * @param param label name
+ * @param number nb of found pairs
+ * @return pointer to the array of 'FLOAT pairs'; NULL if fail
+
+ */
+float *ArgMgr::ArgMgrGetFloatEnum ( const char *param, int *number )
+{
+ char *value = ArgMgrValue(param);
+ float *liste;
+ if (!value)
+ {
+ *number = 0;
+ return 0;
+ }
+ liste = IdStrFloatEnum(value, number);
+ return liste;
+}
+
+// ------------------------ Those are 'service functions' ---------------------
+// ------------------------ internal use only ---------------------
+
/**
* \brief Counts the nb of occurrences of a given charact within a 'string'
* @param chaine Pointer to the 'string'
}
/**
- * \brief renvoie 1 tableau contenant une liste d'intervalles entiers
- * @param value pointer vers la zone allouee contenant les
- * intervalles (deb1,fin1, deb2,fin2, ...)
- * @param number Pointer vers le nb d'interv trouves
- * @return 1 tableau contenant une liste d'intervalles entiers
+ * \brief returns an array of 'INT pairs'
+ * @param value char array decribing a set of 'INT pairs' (f1-l1, f2-l2, ...)
+ * @param number nb of found INT pairs
+ * @return pointer to the array of 'INT pairs'
*/
int *ArgMgr::IdStrIntEnum ( char* value, int *number)
{
int taille;
int i;
- *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Virgules +1 */
+ *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Commas +1 */
taille= *number;
liste = (int *) calloc (1,sizeof(int)*2*taille );
if ( !liste )
}
/**
- * \brief renvoie 1 tableau contenant une liste d'intervalles FLOAT
- * @param value pointer vers la zone allouee contenant les
- * intervalles (deb1,fin1, deb2,fin2, ...)
- * @param number Pointer vers le nb d'interv trouves
- * @return 1 tableau contenant une liste d'intervalles FLOAT
+ * \brief returns an array of set of 'INT16 pairs', passed in Hexadecimal
+ * @param value char array decribing a set of 'INT16 pairs' (f1-l1, f2-l2, ...)
+ * coded in hexadecimal e.g. 0x0008,0x00ac
+ * @param number nb of found pairs
+ * @return array of set of 'INT16 pairs'
+ */
+uint16_t *ArgMgr::IdStrXInt16Enum ( char *value, int *number)
+{
+ uint16_t *liste;
+ int taille;
+ int i;
+
+ *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Commas +1 */
+ taille= *number;
+ liste = (uint16_t *) calloc (1,sizeof(uint16_t)*2*taille );
+ if ( !liste )
+ {
+ return 0;
+ }
+ i=0;
+ while ( taille>0 )
+ {
+ liste[i] = (uint16_t) strtol ( value, &value, 16 );
+ if ( *value == '\0' )
+ {
+ liste[i+1]=liste[i];
+ return liste;
+ }
+ if ( *(value++) != '-' )
+ {
+ liste[i+1]=liste[i];
+ value--;
+ }
+ else
+ {
+ liste[i+1] = (uint16_t) strtol ( value, &value, 16 );
+ }
+ if ( *value == '\0' )
+ return liste;
+ if ( *(value++) != ',' )
+ {
+ free (liste);
+ return 0;
+ }
+ taille --; i+=2;
+ }
+ return liste;
+}
+/**
+ * \brief returns an array of 'FLOAT pairs'
+ * @param value char array decribing a set of 'FLOAT pairs' (f1-l1, f2-l2, ...)
+ * @param number nb of found pairs
+ * @return pointer to the array of 'FLOAT pairs'; NULL if fail
*/
float *ArgMgr::IdStrFloatEnum (char *value, int *number)
{
float *liste;
int taille;
int i;
- *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Virgules +1 */
+ *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Commas +1 */
taille= *number;
liste = (float *) calloc (1,sizeof(float)*2*taille );
if ( !liste )
return liste;
}
-/**
- * \brief decodage des elements d'un argument 'intervalles d'int' de lgr quelconque
- * @param label pointer vers le label de la liste
- * @param number taille de la liste d'intervalles trouvee
- * @return Pointer vers le tableau de taille '2*nbElem'
- * Pointer NULL si erreur
- */
-int *ArgMgr::ArgMgrGetIntEnum ( char *label, int *number )
-{
- char *value = ArgMgrValue(label);
- int *liste;
- if (!value)
- return 0;
- liste = IdStrIntEnum(value, number);
- return liste;
-}
-
-/**
- * \brief decodage des elements d'un argument 'intervalles d'int' de lgr quelconque
- * @param label pointer vers le label de la liste
- * @param number taille de la liste d'intervalles trouvee
- * @return Pointer vers le tableau de taille '2*nbElem'
- * Pointer NULL si erreur
- */
-float *ArgMgr::ArgMgrGetFloatEnum ( char *label, int *number )
-{
- char *value = ArgMgrValue(label);
- float *liste;
- if (!value)
- return 0;
- liste = IdStrFloatEnum(value, number);
- return liste;
-}
-
//-----------------------------------------------------------------------------
// Protected
/**************************************************************************
* *
* Nom de la fonction : Majuscule *
-* Role ............. : Met une chaine de caracteres en majuscules. *
-* parameters ....... : Pointer vers la chaine. *
-* Valeur retournee . : pointer vers cette meme chaine en majuscule. *
+* Role ............. : Creates a new Upper case char array. *
+* parameters ....... : Pointer to the initial char array. * *
+* Valeur retournee . : Pointer to the new Upper case char array. *
* *
**************************************************************************/
-char *ArgMgr::Majuscule (char *chaine )
+char *ArgMgr::Majuscule (const char *chaine )
{
char *ptr, *ptr2, *ptr3;
ptr2 = (char *)malloc(strlen(chaine)*sizeof(char)+1);
ptr3=ptr2;
- for ( ptr = chaine ; *ptr!='\0' ; ptr ++ )
+ for ( ptr = (char *)chaine ; *ptr!='\0' ; ptr ++ )
{
*ptr3 = toupper ( * ptr ); ptr3++;
}
/**************************************************************************
* *
* Nom de la fonction : FiltreLong *
-* Role ............. : Arrete le programme si l'argument est trop long. *
-* ARG_LONG_MAX definit cette longueur. *
-* parameters ....... : Pointer vers l'argument. *
-* Valeur retournee . : Faux s'il n'y a pas d'erreur. *
-* Vrai s'il y a une erreur. *
+* Role ............. : Stops the program if argument is too long. *
+* ARG_LONG_MAX defines max length. *
+* parameters ....... : Pointer to the argument. *
+* Valeur retournee . : false if OK. *
+* true if KO. *
**************************************************************************/
-int ArgMgr::FiltreLong ( char *arg )
+int ArgMgr::FiltreLong ( const char *arg )
{
int n = 0 ;
while ( (n++<ARG_LONG_MAX) && (*(arg++) != '\0') ) ;
}
/*------------------------------------------------------------------------
- | Role : Lit un parameter depuis un fichier
- | Retour : Type : char *
- | Role : pointer vers le label
+ | Role : Reads a parameter from a file
+ | Return : Type : char *
+ | Role : pointer to the label
| parameters : param : char *
- | Role : one ou il faut stocker le parameter
+ | Role : one where the parameter will be stored
| fd : FILE *
- | Role : descripteur du fichier (suppose ouvert)
+ | Role : File description (assumed to be open)
+------------------------------------------------------------------------*/
-char *ArgMgr::LoadedParam ( char *param, FILE *fd )
+const char *ArgMgr::LoadedParam ( const char *param, FILE *fd )
{
int carlu;
- char * car = param;
+ char *car = (char *)param;
int quote = false;
int nbcar = 0;
- /* On supprime les espaces ****/
- /* du debut de chaine *********/
+ /* remove spaces at the beginning****/
while ( isspace(carlu=fgetc (fd)) );
if (carlu==EOF)
return 0;
- /* On cherche une " eventuelle */
+ /* Search for a " */
if ( carlu=='\"' )
{
carlu=fgetc(fd);
quote=true;
- /* On lit tous les caracteres */
+ /* Read all the characters */
}
while ( (carlu!=EOF)
&& ( ( (!quote)&&(!isspace(carlu)) )
}
/*------------------------------------------------------------------------
- | Role : Lecture d'arguments dans un fichier de parameters
- | (cette fonction est recursive).
- | Retour : Type : int
- | Role : retourne le nombre de lettres necessaires
- | pour stocker en memoire tous les parameters
+ | Role : Reading of arguments in a parameter file
+ | (this function is recursive).
+ | Return : Type : int
+ | Role : length needed to store all the parameters
| parameters : filename : char *
- | Role : nom du fichier de parameter
+ | Role : parameter File name
|
+------------------------------------------------------------------------*/
-int ArgMgr::ArgLoadFromFile ( char *filename )
+int ArgMgr::ArgLoadFromFile ( const char *filename )
{
int nbl = 0;
char param[ARG_LONG_MAX+1];
}
/*------------------------------------------------------------------------
- | Role : Gestion des parameters standard de la ligne d'argument.
- | Retour : Type : void
- | parameters : aucun
+ | Role : Standard parameters management (on command line)
+ | Return : Type : void
+ | parameters : none
+------------------------------------------------------------------------*/
void ArgMgr::ArgStdArgs()
{
char *logfile;
FILE *fd;
- if ( (ArgParamOut=ArgMgrValue(ARG_LABEL_PARAMOUT))==0 )
+ if ( (ArgParamOut=ArgMgrValue((char*)ARG_LABEL_PARAMOUT))==0 )
ArgParamOut = ARG_DEFAULT_PARAMOUT;
- if ( (logfile = ArgMgrValue(ARG_LABEL_LOGFILE))!=0)
+ if ( (logfile = ArgMgrValue((char*)ARG_LABEL_LOGFILE))!=0)
{
if ( *logfile == '\0' )
- logfile = ARG_DEFAULT_LOGFILE;
+ logfile = (char *)ARG_DEFAULT_LOGFILE;
fd = fopen ( logfile, "a+" );
if ( fd )
{
}
/*------------------------------------------------------------------------
- | Role : met en majuscule 'sur place'.
- | Retour : Type : char *
+ | Role : Sets in Upper Case.
+ | Return : Type : char *
| parameters : char *
+------------------------------------------------------------------------*/
char *ArgMgr::maj ( char *a )