src/gdcmArgMgr.cxx

   1 /*=========================================================================
   2
   3   Program:   gdcm
   4   Module:    $RCSfile: gdcmArgMgr.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2005/06/08 09:24:17 $
   7   Version:   $Revision: 1.5 $
   8
   9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
  10   l'Image). All rights reserved. See Doc/License.txt or
  11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
  12
  13      This software is distributed WITHOUT ANY WARRANTY; without even
  14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15      PURPOSE.  See the above copyright notices for more information.
  16
  17 =========================================================================*/
  18
  19 #include <stdio.h>
  20 #include <iostream>
  21 #include <ctype.h>
  22 #include <string.h>  // For strlen
  23
  24 #include <string.h>  // For strtok and strlen
  25 #include <stdlib.h>  // For strtol and strtod
  26
  27 #include "gdcmArgMgr.h"
  28
  29 namespace gdcm
  30 {
  31 //-------------------------------------------------------------------------
  32 // Constructor / Destructor
  33
  34 /**
  35  * \brief   constructor
  36  * @param argc arguments count, as passed to main()
  37  * @param argv  pointers array on the arguments passed to main()
  38  */
  39  ArgMgr::ArgMgr(int argc, char *argv[])
  40  {
  41    int i;
  42    int nblettre;
  43    ArgUsed = NULL;
  44    Appel   = NULL;
  45
  46    /* Read the parameters of the command line *************************/
  47    for ( ArgCount=0, nblettre=1 , i=0; i<argc; i++)
  48    {
  49       if ( FiltreLong(argv[i]) )
  50       {
  51           std::cout << "Argument too long ( > "
  52                     << ARG_LONG_MAX << ")" << std::endl;
  53           return;
  54       }
  55       if ( argv[i][0] == '@' )
  56       {
  57          nblettre  += ArgLoadFromFile ( &argv[i][1] );
  58       }
  59       else
  60       {
  61          ArgLab [ArgCount] = strcpy ( (char *)malloc(strlen(argv[i])+1), argv[i] ) ;
  62          nblettre  += 1 + strlen(ArgLab[ArgCount]);
  63          ArgCount++;
  64       }
  65       if (ArgCount >= ARGMAXCOUNT )
  66       {
  67           std::cout << "Too many Arguments ( more than "
  68                     << ARGMAXCOUNT << ")" << std::endl;
  69           return;
  70       }
  71    }
  72
  73    /* Fills an array with the alreadu used parameters ****/
  74    ArgUsed = (char *)calloc (1, ArgCount );
  75
  76    /* Builds the full string with all the parameters  **************/
  77    Appel = (char *) calloc (1, nblettre );
  78
  79    for ( *Appel = '\0', i=0; i<ArgCount; i++)
  80    {
  81       strcat ( Appel, ArgLab [i] ) ;
  82       strcat ( Appel, " " ) ;
  83    }
  84
  85    /* Splitting label from label value *************************************/
  86    for ( i=0; i<ArgCount; i++)
  87    {
  88       char * egaloufin = ArgLab[i] ;
  89       while ( (*egaloufin != '\0') && (*egaloufin != '=') )
  90          egaloufin ++ ;
  91       if ( *egaloufin ) *(egaloufin++) = '\0';
  92       ArgStr[i]= egaloufin;
  93    }
  94
  95    /* Set labels to upper-case (labels are not case sensitive ) *********/
  96    for ( i=0; i<ArgCount; i++)
  97       ArgLab[i] = Majuscule ( ArgLab[i] ) ;
  98
  99   /* Standard arguments are managed by ArgStdArgs **********************/
 100    ArgStdArgs();
 101  }
 102
 103 /**
 104  * \brief  canonical destructor
 105  */
 106 ArgMgr::~ArgMgr()
 107 {
 108    for(int i=0;i<ArgCount;i++)
 109       if(ArgLab[i])
 110          free(ArgLab[i]);
 111    if(ArgUsed)
 112       free(ArgUsed);
 113    if(Appel)
 114       free(Appel);
 115 }
 116
 117 /**
 118  * \brief  checks if a parameter exists in the command line
 119  * @param searchParam  label name
 120  * @return   true if parameter 'label' exists
 121  *           Actually, it returns 0 if label is not found
 122  *           else, returns the number of the spot it was found last time.
 123  */
 124 int ArgMgr::ArgMgrDefined( char *searchParam )
 125 {
 126   int i, trouve ;
 127   char *temp;
 128   temp = Majuscule ( searchParam ) ;
 129   for ( trouve = false, i = ArgCount-1; i>0; i-- )
 130   {
 131     trouve = ! strcmp( ArgLab[i], temp ) ;
 132     if ( trouve )
 133     {
 134       ArgUsed[i] = true ;
 135       for ( int j=1; j<i; j++)
 136       {
 137          if ( (!ArgUsed[j])&&(!strcmp(ArgLab[i],ArgLab[j])) )
 138             ArgUsed[j] = true ;
 139       }
 140       return i ;
 141     }
 142   }
 143   return false ;
 144 }
 145
 146 /**
 147  * \brief  Gets the parameter value, read on the command line
 148  * @param param   name of the searched parameter label
 149  * @return   Value, as a characters string, of the parameter
 150  *            whose label is given.
 151  */
 152 char *ArgMgr::ArgMgrValue ( char *param )
 153 {
 154    int trouve ;
 155    if ( (trouve = ArgMgrDefined ( param )) != false )
 156       return ArgStr[trouve] ;
 157    else
 158       return NULL ;
 159 }
 160
 161 /**
 162  * \brief  Search for the first not yet used label
 163  * @return Pointer to a char array holding the first non used label
 164  */
 165 char *ArgMgr::ArgMgrUnused ( )
 166 {
 167    int i ;
 168    for ( i=ArgCount-1; i>0; i-- )
 169    {
 170       if ( ! ArgUsed[i] )
 171       {
 172          ArgMgrDefined(ArgLab[i]);
 173          return ArgLab[i] ;
 174       }
 175   }
 176   return NULL ;
 177 }
 178
 179 /**
 180  * \brief  Prints unused labels, if any
 181  * @return number of unused labels
 182  */
 183 int ArgMgr::ArgMgrPrintUnusedLabels ()
 184 {
 185    char *label;
 186    int i=0;
 187    while ( (label=ArgMgrUnused())!=0 )
 188    {
 189       if (i==0)
 190          std::cout << "\n Unused Labels:" << std::endl
 191                    << "=============="    << std::endl;
 192       std::cout << "Label : " << label << " = "
 193                 << ArgMgrValue(label) << std::endl;
 194       i++;
 195    }
 196    return i;
 197 }
 198
 199 /**
 200  * \brief  Prints program usage
 201  * @param usage  array of pointers to the documentation lines of the program.
 202  * @return exception code
 203  */
 204 int ArgMgr::ArgMgrUsage(const char **usage_text )
 205 {
 206    while ( *usage_text )
 207       std::cout << std::endl << *(usage_text++);
 208    std::cout << std::endl;
 209    return (0);
 210 }
 211
 212 /**
 213  * \brief Forget it, right now ...
 214  * Saves a char. array in a parameter file
 215  *         whose name is given on command line by : PARAMOUT=???
 216  *         or, as a default, by ARG_DEFAULT_PARAMOUT
 217  * @param param  char. array that defines the parameter:
 218  * @return   Entier correspondant au rang dans la liste de labels
 219  */
 220 int ArgMgr::ArgMgrSave ( char *param )
 221 {
 222    static int   deja = 0;
 223    FILE         *fd;
 224    if ( *ArgParamOut == '\0' )
 225       return 0;
 226    if(deja)
 227    {
 228       fd = fopen ( ArgParamOut, "a+" );
 229    }
 230    else
 231    {
 232       deja = 1;
 233       fd = fopen ( ArgParamOut, "w" );
 234    }
 235    if ( !fd )
 236       return 0;
 237    fprintf ( fd, "%s\n", param );
 238    fclose  ( fd );
 239    return 1;
 240 }
 241
 242 /**
 243  * \brief  Gets an int value passed as an argument to a program
 244  *         (use default value if not found)
 245  *  EXEMPLE:     int dimx = ArgMgrGetInt ( "DIMX", 256 );
 246  * @param label   label name
 247  * @param defaultVal default value
 248  * @return parameter value
 249  */
 250 int ArgMgr::ArgMgrGetInt(char *label, int defaultVal)
 251 {
 252    return ( (ArgMgrDefined(label))
 253             ? (atoi(ArgMgrValue(label)))
 254             : (defaultVal) );
 255 }
 256
 257 /**
 258  * \brief  Gets a float value passed as an argument to a program
 259  *         (use default value if not found)
 260  *  EXEMPLE:     float scale = ArgMgrGetFloat ( "SCALE", 0.33 );
 261  * @param label   label name
 262  * @param defaultVal default value
 263  * @return parameter value
 264  */
 265 float ArgMgr::ArgMgrGetFloat(char *label, float defaultVal)
 266 {
 267    return     ( (ArgMgrDefined(label))
 268                ? ((float)atof(ArgMgrValue(label)))
 269                : (defaultVal) );
 270 }
 271
 272 /**
 273  * \brief  Gets a 'string' value passed as an argument to a program
 274  *         (use default value if not found)
 275  * @param label   label name
 276  * @param defaultVal default value
 277  * @return parameter value
 278  */
 279 char *ArgMgr::ArgMgrGetString(char *label, char *defaultVal)
 280 {
 281    return    ( (ArgMgrDefined(label))
 282               ? (ArgMgrValue(label))
 283               : (defaultVal) );
 284 }
 285
 286 /**
 287  * \brief  Gets a value amongst a set of values
 288  *         (use default value if not found)
 289  *         EXEMPLE:     int nlab = ArgMgrGetLabel("CONFIRM","NO\\YES", 0);
 290  * @param label   label name
 291  * @param liste  character Chain describing the various values.
 292  *               Value are separated by '\\'.
 293  *               Not case sensitive.
 294  * @param val  number of default value
 295  * @return   int : range of value amongst the values list
 296  */
 297 int ArgMgr::ArgMgrGetLabel (char *label, char *liste, int val )
 298 {
 299   char *lab;
 300   char *vallab;
 301   int i = 1;
 302   char *tmp;
 303   tmp = (char *) malloc(strlen(liste)+1);
 304   strcpy(tmp,liste);
 305
 306   if ( (vallab = ArgMgrGetString(label,(char *)NULL)) != 0 )
 307   {
 308      for ( lab = strtok (tmp,"\\");
 309            lab != 0;
 310            lab = strtok(0L,"\\"), i++ )
 311      {
 312         if ( strcmp(maj(lab),maj(vallab))==0)
 313            return i;
 314      }
 315      val=0;
 316    }
 317    free(tmp);
 318    return val;
 319 }
 320
 321 /**
 322  * \brief  Demands a value amongst a set of values (abort if not found)
 323  *         EXEMPLE:     int nlab = ArgMgrWantLabel("CONFIRM","NO\\YES", usage);
 324  * @param label   label name
 325  * @param liste  character Chain describing the various values.
 326  *               Labels are separated by  '\\'.
 327  *               No case sensitive.
 328  * @param usage Usage program (displayed if label not found)
 329  * @return   int : range of value amongst the values list
 330  */
 331 int ArgMgr::ArgMgrWantLabel (char *label, char *liste, const char *usage[] )
 332 {
 333    char *lab;
 334    char *vallab;
 335    int i = 1;
 336    if ( (vallab = ArgMgrGetString(label,0)) != 0 )
 337    {
 338       for ( lab = strtok (liste,"\\"); lab != 0; lab = strtok(0L,"\\"), i++ )
 339         if ( strcmp(maj(lab),maj(vallab))==0)
 340            return i;
 341       return 0;
 342    }
 343    ArgMgrUsage(usage);
 344    return 0;
 345 }
 346
 347 /**
 348  * \brief  Demands an int value passed as an argument to a program
 349  *         If not found usage is displayed and the prog aborted
 350  *  EXEMPLE:     int dimx = ArgMgrWantInt ( "DIMX", usage );
 351  * @param label   label name
 352  * @param usage Usage program (displayed if label not found)
 353  * @return parameter value
 354  */
 355 int ArgMgr::ArgMgrWantInt (char *label, const char **usage)
 356 {
 357    return        ( (ArgMgrDefined(label) )
 358                  ? (atoi(ArgMgrValue(label) ) )
 359                  : (ArgMgrUsage(usage),1) );
 360 }
 361
 362 /**
 363  * \brief  Demands a float value passed as an argument to a program
 364  *         If not found usage is displayed and the prog aborted
 365  *  EXEMPLE:     float scale = ArgMgrWantFloat ( "SCALE", usage );
 366  * @param label   label name
 367  * @param usage Usage program (displayed if label not found)
 368  * @return parameter value
 369  */
 370 float ArgMgr::ArgMgrWantFloat (char *label, const char **usage)
 371 {
 372    return       ( (ArgMgrDefined(label) )
 373                 ? ((float)atof(ArgMgrValue(label) ) )
 374                 : (ArgMgrUsage(usage),1.0) );
 375 }
 376
 377 /**
 378  * \brief  Demands a 'string' value passed as an argument to a program
 379  *         If not found usage is displayed and the prog aborted
 380  *  EXEMPLE:     char *code = ArgMgrWantString ( "CODE", usage );
 381  * @param label   Parameter label
 382  * @param usage Usage program (displayed if label not found)
 383  * @return parameter value
 384  */
 385 char *ArgMgr::ArgMgrWantString(char *label, const char **usage)
 386 {
 387    return      ( (ArgMgrDefined(label) )
 388                ? (ArgMgrValue(label) )
 389                : (ArgMgrUsage(usage),(char*)0) );
 390 }
 391
 392 /**
 393  * \brief  decodage des elements d'un argument 'ensemble de STRING' de lgr qcq
 394  * @param label   label name
 395  * @param number  nb of found elements
 396  * @return   Pointer to the array
 397  *     Pointer NULL if error
 398  */
 399 char **ArgMgr::ArgMgrGetListOfString ( char *label, int *nbElem )
 400 {
 401   int taille;
 402   char  *value = ArgMgrValue(label);
 403   char **liste;
 404   char **elem;
 405   char  *chainecur;
 406   if (!value)
 407      return 0;
 408   *nbElem = IdStrCountChar(value,',')+1; /* nb Elements = nb Commas +1 */
 409   taille = *nbElem;
 410   liste = (char **) malloc (sizeof(char*) * taille + strlen(value)+1);
 411   if ( !liste )
 412      return 0;
 413   value = strcpy( ((char*)liste)+sizeof(char*) * taille, value );
 414   for ( elem = liste, chainecur = strtok(value,", ");
 415         taille>0;
 416         taille--, chainecur = (chainecur) ? strtok ( 0, ", " ) : 0 )
 417   {
 418     *(elem++) = chainecur;
 419   }
 420   return liste;
 421 }
 422
 423 /**
 424  * \brief  decodage des elements d'un argument 'liste d'INTEGER' de lgr qcq
 425  * @param label   label name
 426  * @param number  nb of found elements
 427  * @return   Pointer to the array
 428  *     Pointer NULL if error
 429  */
 430 int *ArgMgr::ArgMgrGetListOfInt ( char *label, int *number )
 431 {
 432   char *value = ArgMgrValue(label);
 433   int *liste;
 434   int *elem;
 435   int taille;
 436   if (!value)
 437      return 0;
 438   *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Commas +1 */
 439   taille= *number;
 440   liste = (int *) calloc (1,sizeof(int)*taille );
 441   if ( !liste )
 442      return 0;
 443   elem = liste;
 444   *number = 1;
 445
 446   while ( taille>0 )
 447   {
 448     *(elem++) = (int) strtol ( value, &value, 10 );
 449     if ( *value == '\0' )
 450        return liste;
 451     if ( *(value++) != ',' )
 452     {
 453       free (liste);
 454       return 0;
 455     }
 456     taille --;
 457   }
 458 return liste;
 459 }
 460
 461 /**
 462  * \brief  decodage des elements d'un argument 'liste de FLOAT' de lgr qcq
 463  * @param label   label name
 464  * @param number  taille de la liste  trouvee
 465  * @return   Pointer vers le tableau de lgr 'taille'
 466  *     NULL if error
 467  */
 468 float *ArgMgr::ArgMgrGetListOfFloat ( char *label, int *number )
 469 {
 470   char *value = ArgMgrValue(label);
 471   float *liste;
 472   float *elem;
 473   int taille;
 474   if (!value)
 475     return 0;
 476   *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Commas +1 */
 477   taille= *number;
 478   liste = (float *) calloc (1,sizeof(float)*taille );
 479   if ( !liste )
 480      return 0;
 481   elem = liste;
 482   *number = 1;
 483
 484   while ( taille>0 )
 485   {
 486     *(elem++) = (float) strtod ( value, &value );
 487     if ( *value == '\0' )
 488        return liste;
 489     if ( *(value++) != ',' )
 490     {
 491       free (liste);
 492       return 0;
 493     }
 494     taille --;
 495   }
 496 return liste;
 497 }
 498
 499 /**
 500  * \brief     Counts the nb of occurrences of a given charact within a 'string'
 501  * @param chaine     Pointer to the 'string'
 502  * @param caract     charact to count
 503  * @return       occurence number
 504  */
 505 int ArgMgr::IdStrCountChar (char *chaine, int caract)
 506 {
 507   int i=0;
 508   char *ptr;
 509   for ( ptr = chaine ; *ptr!='\0' ; ptr ++ )
 510      if (*ptr==caract)
 511         i++;
 512   return i;
 513 }
 514
 515 /**
 516  * \brief     renvoie 1 tableau contenant un ensemble de paires d'entiers
 517  * @param value     pointer vers la zone allouee contenant les
 518  *    intervalles (deb1,fin1, deb2,fin2, ...)
 519  * @param number     Pointer vers le nb de paires trouvees
 520  * @return        1 tableau contenant un ensemble de paires d'entiers
 521  */
 522 int *ArgMgr::IdStrIntEnum ( char* value, int *number)
 523 {
 524    int* liste;
 525    int taille;
 526    int i;
 527
 528    *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Virgules +1 */
 529    taille= *number;
 530    liste = (int *) calloc (1,sizeof(int)*2*taille );
 531    if ( !liste )
 532    {
 533       return 0;
 534    }
 535    i=0;
 536    while ( taille>0 )
 537    {
 538       liste[i] = (int) strtol ( value, &value, 10 );
 539       if ( *value == '\0' )
 540       {
 541          liste[i+1]=liste[i];
 542          return liste;
 543       }
 544       if ( *(value++) != '-' )
 545       {
 546          liste[i+1]=liste[i];
 547          value--;
 548        }
 549        else
 550        {
 551           liste[i+1] = (int) strtol ( value, &value, 10 );
 552        }
 553        if ( *value == '\0' )
 554           return liste;
 555        if ( *(value++) != ',' )
 556        {
 557           free (liste);
 558           return 0;
 559        }
 560        taille --; i+=2;
 561    }
 562    return liste;
 563 }
 564
 565 /**
 566  * \brief     renvoie 1 tableau contenant un ensemble de 'paires' de FLOAT
 567  * @param value     pointer vers la zone allouee contenant les
 568  *     paires (deb1,fin1, deb2,fin2, ...)
 569  * @param number     Pointer vers le nb de paires trouvees
 570  * @return         tableau contenant un ensemble de 'paires' de FLOAT
 571  */
 572 float *ArgMgr::IdStrFloatEnum (char *value, int *number)
 573 {
 574    float *liste;
 575    int taille;
 576    int i;
 577    *number = IdStrCountChar(value,',')+1; /* nb Elements = nb Virgules +1 */
 578    taille= *number;
 579    liste = (float *) calloc (1,sizeof(float)*2*taille );
 580    if ( !liste )
 581       return 0;
 582    i=0;
 583    while ( taille>0 )
 584    {
 585       liste[i] = (float) strtod ( value, &value );
 586       if ( *value == '\0' )
 587       {
 588          liste[i+1]=liste[i];
 589          return liste;
 590       }
 591       if ( *(value++) != '-' )
 592       {
 593          liste[i+1]=liste[i];
 594          value--;
 595       }
 596       else
 597       {
 598           liste[i+1] = (float) strtod ( value, &value );
 599       }
 600       if ( *value == '\0' )
 601          return liste;
 602       if ( *(value++) != ',' )
 603       {
 604          free (liste);
 605          return 0;
 606       }
 607       taille --; i+=2;
 608    }
 609    return liste;
 610 }
 611
 612 /**
 613  * \brief  decodage des elements d'un argument 'paires d'int' de lgr quelconque
 614  * @param label   label name
 615  * @param number  taille de l'ensemble de paires trouvee
 616  * @return   Pointer vers le tableau de taille '2*nbElem'
 617  *     Pointer NULL si erreur
 618  */
 619 int *ArgMgr::ArgMgrGetIntEnum ( char *label, int *number )
 620 {
 621    char *value = ArgMgrValue(label);
 622    int *liste;
 623    if (!value)
 624       return 0;
 625    liste = IdStrIntEnum(value, number);
 626    return liste;
 627 }
 628
 629 /**
 630  * \brief  decodage des elements d'un argument 'paires de float' de lgr quelconque
 631  * @param label   label name
 632  * @param number  taille de l'ensemble de paires trouvee
 633  * @return   Pointer vers le tableau de taille '2*nbElem'
 634  *     Pointer NULL si erreur
 635  */
 636 float *ArgMgr::ArgMgrGetFloatEnum ( char *label, int *number )
 637 {
 638    char  *value = ArgMgrValue(label);
 639    float *liste;
 640    if (!value)
 641       return 0;
 642    liste = IdStrFloatEnum(value, number);
 643    return liste;
 644 }
 645
 646 //-----------------------------------------------------------------------------
 647 // Protected
 648
 649 //-----------------------------------------------------------------------------
 650 // Private
 651
 652 /**************************************************************************
 653 *                                                                         *
 654 * Nom de la fonction : Majuscule                                          *
 655 * Role ............. : Creates a new Upper case char array.               *
 656 * parameters ....... : Pointer to the initial char array.                 *                           *
 657 * Valeur retournee . : Pointer to the new Upper case char array.          *
 658 *                                                                         *
 659 **************************************************************************/
 660 char *ArgMgr::Majuscule (char *chaine )
 661 {
 662   char *ptr, *ptr2, *ptr3;
 663   ptr2 = (char *)malloc(strlen(chaine)*sizeof(char)+1);
 664   ptr3=ptr2;
 665   for ( ptr = chaine ; *ptr!='\0' ; ptr ++ )
 666    {
 667        *ptr3 = toupper ( * ptr ); ptr3++;
 668    }
 669   *ptr3='\0';
 670   return ptr2;
 671 }
 672
 673 /**************************************************************************
 674 *                                                                         *
 675 * Nom de la fonction : FiltreLong                                         *
 676 * Role ............. : Stops the program if argument is too long.         *
 677 *                      ARG_LONG_MAX defines max length.                   *
 678 * parameters ....... : Pointer to the argument.                           *
 679 * Valeur retournee . : false if OK.                                       *
 680 *                      true if KO.                                        *
 681 **************************************************************************/
 682 int ArgMgr::FiltreLong ( char *arg  )
 683 {
 684   int  n = 0 ;
 685   while ( (n++<ARG_LONG_MAX) && (*(arg++) != '\0') ) ;
 686   return (n>=ARG_LONG_MAX) ;
 687 }
 688
 689 /*------------------------------------------------------------------------
 690  | Role       : Reads a parameter from a file
 691  | Return     : Type   : char *
 692  |              Role   : pointer to the label
 693  | parameters : param  : char *
 694  |              Role   : one where the parameter will be stored
 695  |              fd     : FILE *
 696  |              Role   : File description (assumed to be open)
 697  +------------------------------------------------------------------------*/
 698 char *ArgMgr::LoadedParam ( char *param, FILE *fd )
 699 {
 700   int    carlu;
 701   char * car = param;
 702   int    quote = false;
 703   int    nbcar = 0;
 704
 705   /* remove spaces at the beginning****/
 706   while ( isspace(carlu=fgetc (fd)) );
 707   if (carlu==EOF)
 708      return 0;
 709   /* Search for a " */
 710   if ( carlu=='\"' )
 711   {
 712     carlu=fgetc(fd);
 713     quote=true;
 714   /* Read all the characters */
 715   }
 716   while (  (carlu!=EOF)
 717         && (  ( (!quote)&&(!isspace(carlu)) )
 718          ||( (quote)&& !(carlu=='\"')   ) ) )
 719   {
 720      *(car++) = (char) carlu;
 721      nbcar ++;
 722   /* sans depasser la taille max*/
 723      if ( nbcar >= ARG_LONG_MAX )
 724      {
 725         std::cout << "\nError: Argument too long ( > "
 726                   << ARG_LONG_MAX << ")in parameter file."
 727                   << std::endl;
 728         break;
 729      }
 730      carlu = fgetc(fd);
 731   }
 732   *car = '\0';
 733   return param;
 734 }
 735
 736 /*------------------------------------------------------------------------
 737  | Role       : Reading of arguments in a parameter file
 738  |              (this function is recursive).
 739  | Return     : Type   : int
 740  |              Role   : length needed to store all the parameters
 741  | parameters : filename : char *
 742  |              Role     : parameter File name
 743  |
 744  +------------------------------------------------------------------------*/
 745 int ArgMgr::ArgLoadFromFile ( char *filename )
 746 {
 747   int   nbl = 0;
 748   char  param[ARG_LONG_MAX+1];
 749   FILE  *fch;
 750
 751   fch = fopen ( filename, ID_RFILE_TEXT );
 752   while ( LoadedParam (param, fch ) )
 753   {
 754     int n = strlen(param);
 755     if ( param[0]=='@' )
 756     {
 757       nbl  += ArgLoadFromFile ( &param[1] );
 758     }
 759     else
 760     {
 761       ArgLab [ArgCount] = strcpy ((char *) malloc(n+1), param ) ;
 762       nbl += n + 1 ;
 763       ArgCount++;
 764       if ( ArgCount >= ARGMAXCOUNT )
 765          break;
 766     }
 767   }
 768   fclose ( fch );
 769   return nbl;
 770 }
 771
 772 /*------------------------------------------------------------------------
 773  | Role       : Standard parameters management (on command line)
 774  | Return     : Type   : void
 775  | parameters : none
 776  +------------------------------------------------------------------------*/
 777 void ArgMgr::ArgStdArgs()
 778 {
 779   char *logfile;
 780   FILE *fd;
 781
 782   if ( (ArgParamOut=ArgMgrValue(ARG_LABEL_PARAMOUT))==0 )
 783     ArgParamOut = ARG_DEFAULT_PARAMOUT;
 784   if ( (logfile = ArgMgrValue(ARG_LABEL_LOGFILE))!=0)
 785   {
 786     if ( *logfile == '\0' )
 787        logfile = (char *)ARG_DEFAULT_LOGFILE;
 788     fd = fopen ( logfile, "a+" );
 789     if ( fd )
 790     {
 791       fprintf ( fd, "%s\n", Appel );
 792       fclose  ( fd );
 793     }
 794   }
 795 }
 796
 797 /*------------------------------------------------------------------------
 798  | Role       : Sets in Upper Case.
 799  | Return     : Type   : char *
 800  | parameters : char *
 801  +------------------------------------------------------------------------*/
 802 char *ArgMgr::maj ( char *a )
 803 {
 804    char *b = a;
 805    while ( *b !=0 )
 806    {
 807       if ( *b<='z' && *b>='a' ) *b = *b+'A'-'a';
 808       b++;
 809    }
 810    return a;
 811 }
 812 //-----------------------------------------------------------------------------
 813 // Print
 814
 815 //-----------------------------------------------------------------------------
 816 } // end namespace gdcm