X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmArgMgr.cxx;h=3ed2d808dca3be955067b6e5e6a923c844774164;hb=17daf7e7caceddf44e73864ee8d366613a1f0c82;hp=96ef10fd29ef0cae3819a075aac7ded83ddd2fdd;hpb=d660de8252252f981699115eac611a8ec0b3ad5f;p=gdcm.git

diff --git a/src/gdcmArgMgr.cxx b/src/gdcmArgMgr.cxx
index 96ef10fd..3ed2d808 100644
--- a/src/gdcmArgMgr.cxx
+++ b/src/gdcmArgMgr.cxx
@@ -3,8 +3,8 @@
   Program:   gdcm
   Module:    $RCSfile: gdcmArgMgr.cxx,v $
   Language:  C++
-  Date:      $Date: 2005/06/06 12:37:58 $
-  Version:   $Revision: 1.1 $
+  Date:      $Date: 2005/09/20 09:21:35 $
+  Version:   $Revision: 1.15 $
   
   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
   l'Image). All rights reserved. See Doc/License.txt or
@@ -26,10 +26,6 @@
 
 #include "gdcmArgMgr.h"
 
-#define ARG_DEFAULT_PARAMOUT    "fileout.par"
-#define ARG_DEFAULT_LOGFILE     "gdcm.log"
-
-
 namespace gdcm 
 {
 //-------------------------------------------------------------------------
@@ -40,7 +36,7 @@ namespace gdcm
  * @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;
@@ -74,7 +70,7 @@ namespace gdcm
       }
    }
 
-   /* 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  **************/
@@ -110,50 +106,50 @@ namespace gdcm
 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 )
     {
       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 ;
+  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 )
@@ -164,7 +160,7 @@ char *ArgMgr::ArgMgrValue ( char *param )
 
 /**
  * \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 ( )
 {
@@ -202,26 +198,23 @@ int ArgMgr::ArgMgrPrintUnusedLabels ()
 
 /**
  * \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 )
@@ -230,7 +223,7 @@ int ArgMgr::ArgMgrSave ( char *param )
    FILE         *fd;
    if ( *ArgParamOut == '\0' )
       return 0;
-   if(deja) 
+   if ( deja ) 
    {
       fd = fopen ( ArgParamOut, "a+" );
    }
@@ -249,12 +242,12 @@ int ArgMgr::ArgMgrSave ( char *param )
 /**
  * \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)))
@@ -264,44 +257,45 @@ int ArgMgr::ArgMgrGetInt(char *label, int defaultVal)
 /**
  * \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)
+char *ArgMgr::ArgMgrGetString(const char *param, 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, char *liste, int val )
 {
   char *lab;
   char *vallab;
@@ -310,7 +304,7 @@ int ArgMgr::ArgMgrGetLabel (char *label, char *liste, int val )
   tmp = (char *) malloc(strlen(liste)+1);
   strcpy(tmp,liste);
 
-  if ( (vallab = ArgMgrGetString(label,(char *)NULL)) != 0 ) 
+  if ( (vallab = ArgMgrGetString(param,(char *)NULL)) != 0 ) 
   { 
      for ( lab = strtok (tmp,"\\"); 
            lab != 0; 
@@ -326,21 +320,21 @@ int ArgMgr::ArgMgrGetLabel (char *label, char *liste, int val )
 }
 
 /**
- * \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.
  * @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;
    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) 
@@ -354,12 +348,12 @@ int ArgMgr::ArgMgrWantLabel (char *label, char *liste, char *usage[] )
 /**
  * \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) ) ) 
@@ -369,27 +363,27 @@ int ArgMgr::ArgMgrWantInt (char *label, char **usage)
 /**
  * \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) ) 
@@ -397,13 +391,13 @@ char *ArgMgr::ArgMgrWantString(char *label, char **usage)
 }
 
 /**
- * \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);
@@ -412,8 +406,8 @@ char **ArgMgr::ArgMgrGetListOfString ( char *label, int *nbElem )
   char  *chainecur; 
   if (!value)
      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;
@@ -428,13 +422,13 @@ char **ArgMgr::ArgMgrGetListOfString ( char *label, int *nbElem )
 }
 
 /**
- * \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;
@@ -466,13 +460,12 @@ return liste;
 }
 
 /**
- * \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;
@@ -503,6 +496,66 @@ float *ArgMgr::ArgMgrGetListOfFloat ( char *label, int *number )
 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'
@@ -520,11 +573,10 @@ int ArgMgr::IdStrCountChar (char *chaine, int caract)
 }
 
 /**
- * \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)
 {
@@ -532,7 +584,7 @@ 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 )
@@ -570,18 +622,66 @@ int *ArgMgr::IdStrIntEnum ( char* value, int *number)
 }
 
 /**
- * \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 )
@@ -616,40 +716,6 @@ float *ArgMgr::IdStrFloatEnum (char *value, int *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
- */
-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
 
@@ -659,17 +725,17 @@ float *ArgMgr::ArgMgrGetFloatEnum ( char *label, int *number )
 /**************************************************************************
 *                                                                         *
 * 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++; 
    }
@@ -680,11 +746,11 @@ char *ArgMgr::Majuscule (char *chaine )
 /**************************************************************************
 *                                                                         *
 * 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  )
 {
@@ -694,32 +760,31 @@ int ArgMgr::FiltreLong ( char *arg  )
 }
 
 /*------------------------------------------------------------------------
- | 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)) )
@@ -742,13 +807,12 @@ char *ArgMgr::LoadedParam ( char *param, FILE *fd )
 }
 
 /*------------------------------------------------------------------------
- | 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 )
@@ -779,21 +843,21 @@ int ArgMgr::ArgLoadFromFile ( char *filename )
 }
 
 /*------------------------------------------------------------------------
- | 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 ) 
     {
@@ -804,8 +868,8 @@ void ArgMgr::ArgStdArgs()
 }
 
 /*------------------------------------------------------------------------
- | Role       : met en majuscule 'sur place'.
- | Retour     : Type   : char *
+ | Role       : Sets in Upper Case.
+ | Return     : Type   : char *
  | parameters : char *
  +------------------------------------------------------------------------*/
 char *ArgMgr::maj ( char *a )