external/bsd/ntp/dist/sntp/libopts/save.c

   1 /*      $NetBSD$        */
   2
   3
   4 /*
   5  *  save.c  Id: 5a69234fab4c2d8d7eaf4aed4dbb3052ce6be5b6
   6  * Time-stamp:      "2009-07-20 20:40:28 bkorb"
   7  *
   8  *  This module's routines will take the currently set options and
   9  *  store them into an ".rc" file for re-interpretation the next
  10  *  time the invoking program is run.
  11  *
  12  *  This file is part of AutoOpts, a companion to AutoGen.
  13  *  AutoOpts is free software.
  14  *  AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
  15  *
  16  *  AutoOpts is available under any one of two licenses.  The license
  17  *  in use must be one of these two and the choice is under the control
  18  *  of the user of the license.
  19  *
  20  *   The GNU Lesser General Public License, version 3 or later
  21  *      See the files "COPYING.lgplv3" and "COPYING.gplv3"
  22  *
  23  *   The Modified Berkeley Software Distribution License
  24  *      See the file "COPYING.mbsd"
  25  *
  26  *  These files have the following md5sums:
  27  *
  28  *  43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
  29  *  06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
  30  *  66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
  31  */
  32
  33 static char const  zWarn[] = "%s WARNING:  cannot save options - ";
  34 static char const close_xml[] = "</%s>\n";
  35
  36 /* = = = START-STATIC-FORWARD = = = */
  37 /* static forward declarations maintained by mk-fwd */
  38 static tCC*
  39 findDirName( tOptions* pOpts, int* p_free );
  40
  41 static tCC*
  42 findFileName( tOptions* pOpts, int* p_free_name );
  43
  44 static void
  45 printEntry(
  46     FILE *     fp,
  47     tOptDesc * p,
  48     tCC*       pzLA );
  49
  50 static void
  51 print_a_value(FILE * fp, int depth, tOptDesc * pOD, tOptionValue const * ovp);
  52
  53 static void
  54 print_a_string(FILE * fp, char const * name, char const * pz);
  55
  56 static void
  57 printValueList(FILE * fp, char const * name, tArgList * al);
  58
  59 static void
  60 printHierarchy(FILE * fp, tOptDesc * p);
  61
  62 static FILE *
  63 openSaveFile( tOptions* pOpts );
  64
  65 static void
  66 printNoArgOpt(FILE * fp, tOptDesc * p, tOptDesc * pOD);
  67
  68 static void
  69 printStringArg(FILE * fp, tOptDesc * pOD);
  70
  71 static void
  72 printEnumArg(FILE * fp, tOptDesc * pOD);
  73
  74 static void
  75 printSetMemberArg(FILE * fp, tOptDesc * pOD);
  76
  77 static void
  78 printFileArg(FILE * fp, tOptDesc * pOD, tOptions* pOpts);
  79 /* = = = END-STATIC-FORWARD = = = */
  80
  81 static tCC*
  82 findDirName( tOptions* pOpts, int* p_free )
  83 {
  84     tCC*  pzDir;
  85
  86     if (  (pOpts->specOptIdx.save_opts == NO_EQUIVALENT)
  87        || (pOpts->specOptIdx.save_opts == 0))
  88         return NULL;
  89
  90     pzDir = pOpts->pOptDesc[ pOpts->specOptIdx.save_opts ].optArg.argString;
  91     if ((pzDir != NULL) && (*pzDir != NUL))
  92         return pzDir;
  93
  94     /*
  95      *  This function only works if there is a directory where
  96      *  we can stash the RC (INI) file.
  97      */
  98     {
  99         tCC* const* papz = pOpts->papzHomeList;
 100         if (papz == NULL)
 101             return NULL;
 102
 103         while (papz[1] != NULL) papz++;
 104         pzDir = *papz;
 105     }
 106
 107     /*
 108      *  IF it does not require deciphering an env value, then just copy it
 109      */
 110     if (*pzDir != '$')
 111         return pzDir;
 112
 113     {
 114         tCC*  pzEndDir = strchr( ++pzDir, DIRCH );
 115         char* pzFileName;
 116         char* pzEnv;
 117
 118         if (pzEndDir != NULL) {
 119             char z[ AO_NAME_SIZE ];
 120             if ((pzEndDir - pzDir) > AO_NAME_LIMIT )
 121                 return NULL;
 122             strncpy( z, pzDir, (size_t)(pzEndDir - pzDir) );
 123             z[ (pzEndDir - pzDir) ] = NUL;
 124             pzEnv = getenv( z );
 125         } else {
 126
 127             /*
 128              *  Make sure we can get the env value (after stripping off
 129              *  any trailing directory or file names)
 130              */
 131             pzEnv = getenv( pzDir );
 132         }
 133
 134         if (pzEnv == NULL) {
 135             fprintf( stderr, zWarn, pOpts->pzProgName );
 136             fprintf( stderr, zNotDef, pzDir );
 137             return NULL;
 138         }
 139
 140         if (pzEndDir == NULL)
 141             return pzEnv;
 142
 143         {
 144             size_t sz = strlen( pzEnv ) + strlen( pzEndDir ) + 2;
 145             pzFileName = (char*)AGALOC( sz, "dir name" );
 146         }
 147
 148         if (pzFileName == NULL)
 149             return NULL;
 150
 151         *p_free = 1;
 152         /*
 153          *  Glue together the full name into the allocated memory.
 154          *  FIXME: We lose track of this memory.
 155          */
 156         sprintf( pzFileName, "%s/%s", pzEnv, pzEndDir );
 157         return pzFileName;
 158     }
 159 }
 160
 161
 162 static tCC*
 163 findFileName( tOptions* pOpts, int* p_free_name )
 164 {
 165     tCC*   pzDir;
 166     struct stat stBuf;
 167     int    free_dir_name = 0;
 168
 169     pzDir = findDirName( pOpts, &free_dir_name );
 170     if (pzDir == NULL)
 171         return NULL;
 172
 173     /*
 174      *  See if we can find the specified directory.  We use a once-only loop
 175      *  structure so we can bail out early.
 176      */
 177     if (stat( pzDir, &stBuf ) != 0) do {
 178
 179         /*
 180          *  IF we could not, check to see if we got a full
 181          *  path to a file name that has not been created yet.
 182          */
 183         if (errno == ENOENT) {
 184             char z[AG_PATH_MAX];
 185
 186             /*
 187              *  Strip off the last component, stat the remaining string and
 188              *  that string must name a directory
 189              */
 190             char* pzDirCh = strrchr( pzDir, DIRCH );
 191             if (pzDirCh == NULL) {
 192                 stBuf.st_mode = S_IFREG;
 193                 continue;  /* bail out of error condition */
 194             }
 195
 196             strncpy( z, pzDir, (size_t)(pzDirCh - pzDir));
 197             z[ pzDirCh - pzDir ] = NUL;
 198
 199             if (  (stat( z, &stBuf ) == 0)
 200                && S_ISDIR( stBuf.st_mode )) {
 201
 202                 /*
 203                  *  We found the directory.  Restore the file name and
 204                  *  mark the full name as a regular file
 205                  */
 206                 stBuf.st_mode = S_IFREG;
 207                 continue;  /* bail out of error condition */
 208             }
 209         }
 210
 211         /*
 212          *  We got a bogus name.
 213          */
 214         fprintf( stderr, zWarn, pOpts->pzProgName );
 215         fprintf( stderr, zNoStat, errno, strerror( errno ), pzDir );
 216         if (free_dir_name)
 217             AGFREE( (void*)pzDir );
 218         return NULL;
 219     } while (0);
 220
 221     /*
 222      *  IF what we found was a directory,
 223      *  THEN tack on the config file name
 224      */
 225     if (S_ISDIR( stBuf.st_mode )) {
 226         size_t sz = strlen( pzDir ) + strlen( pOpts->pzRcName ) + 2;
 227
 228         {
 229             char*  pzPath = (char*)AGALOC( sz, "file name" );
 230 #ifdef HAVE_SNPRINTF
 231             snprintf( pzPath, sz, "%s/%s", pzDir, pOpts->pzRcName );
 232 #else
 233             sprintf( pzPath, "%s/%s", pzDir, pOpts->pzRcName );
 234 #endif
 235             if (free_dir_name)
 236                 AGFREE( (void*)pzDir );
 237             pzDir = pzPath;
 238             free_dir_name = 1;
 239         }
 240
 241         /*
 242          *  IF we cannot stat the object for any reason other than
 243          *     it does not exist, then we bail out
 244          */
 245         if (stat( pzDir, &stBuf ) != 0) {
 246             if (errno != ENOENT) {
 247                 fprintf( stderr, zWarn, pOpts->pzProgName );
 248                 fprintf( stderr, zNoStat, errno, strerror( errno ),
 249                          pzDir );
 250                 AGFREE( (void*)pzDir );
 251                 return NULL;
 252             }
 253
 254             /*
 255              *  It does not exist yet, but it will be a regular file
 256              */
 257             stBuf.st_mode = S_IFREG;
 258         }
 259     }
 260
 261     /*
 262      *  Make sure that whatever we ultimately found, that it either is
 263      *  or will soon be a file.
 264      */
 265     if (! S_ISREG( stBuf.st_mode )) {
 266         fprintf( stderr, zWarn, pOpts->pzProgName );
 267         fprintf( stderr, zNotFile, pzDir );
 268         if (free_dir_name)
 269             AGFREE( (void*)pzDir );
 270         return NULL;
 271     }
 272
 273     /*
 274      *  Get rid of the old file
 275      */
 276     unlink( pzDir );
 277     *p_free_name = free_dir_name;
 278     return pzDir;
 279 }
 280
 281
 282 static void
 283 printEntry(
 284     FILE *     fp,
 285     tOptDesc * p,
 286     tCC*       pzLA )
 287 {
 288     /*
 289      *  There is an argument.  Pad the name so values line up.
 290      *  Not disabled *OR* this got equivalenced to another opt,
 291      *  then use current option name.
 292      *  Otherwise, there must be a disablement name.
 293      */
 294     {
 295         char const * pz;
 296         if (! DISABLED_OPT(p) || (p->optEquivIndex != NO_EQUIVALENT))
 297             pz = p->pz_Name;
 298         else
 299             pz = p->pz_DisableName;
 300
 301         fprintf(fp, "%-18s", pz);
 302     }
 303     /*
 304      *  IF the option is numeric only,
 305      *  THEN the char pointer is really the number
 306      */
 307     if (OPTST_GET_ARGTYPE(p->fOptState) == OPARG_TYPE_NUMERIC)
 308         fprintf( fp, "  %d\n", (int)(t_word)pzLA );
 309
 310     /*
 311      *  OTHERWISE, FOR each line of the value text, ...
 312      */
 313     else if (pzLA == NULL)
 314         fputc( '\n', fp );
 315
 316     else {
 317         fputc( ' ', fp ); fputc( ' ', fp );
 318         for (;;) {
 319             tCC* pzNl = strchr( pzLA, '\n' );
 320
 321             /*
 322              *  IF this is the last line
 323              *  THEN bail and print it
 324              */
 325             if (pzNl == NULL)
 326                 break;
 327
 328             /*
 329              *  Print the continuation and the text from the current line
 330              */
 331             (void)fwrite( pzLA, (size_t)(pzNl - pzLA), (size_t)1, fp );
 332             pzLA = pzNl+1; /* advance the Last Arg pointer */
 333             fputs( "\\\n", fp );
 334         }
 335
 336         /*
 337          *  Terminate the entry
 338          */
 339         fputs( pzLA, fp );
 340         fputc( '\n', fp );
 341     }
 342 }
 343
 344
 345 static void
 346 print_a_value(FILE * fp, int depth, tOptDesc * pOD, tOptionValue const * ovp)
 347 {
 348     static char const bool_atr[]  = "<%1$s type=boolean>%2$s</%1$s>\n";
 349     static char const numb_atr[]  = "<%1$s type=integer>0x%2$lX</%1$s>\n";
 350     static char const type_atr[]  = "<%s type=%s>";
 351     static char const null_atr[]  = "<%s/>\n";
 352
 353     while (--depth >= 0)
 354         putc(' ', fp), putc(' ', fp);
 355
 356     switch (ovp->valType) {
 357     default:
 358     case OPARG_TYPE_NONE:
 359         fprintf(fp, null_atr, ovp->pzName);
 360         break;
 361
 362     case OPARG_TYPE_STRING:
 363         print_a_string(fp, ovp->pzName, ovp->v.strVal);
 364         break;
 365
 366     case OPARG_TYPE_ENUMERATION:
 367     case OPARG_TYPE_MEMBERSHIP:
 368         if (pOD != NULL) {
 369             tAoUI     opt_state = pOD->fOptState;
 370             uintptr_t val = pOD->optArg.argEnum;
 371             char const * typ = (ovp->valType == OPARG_TYPE_ENUMERATION)
 372                 ? "keyword" : "set-membership";
 373
 374             fprintf(fp, type_atr, ovp->pzName, typ);
 375
 376             /*
 377              *  This is a magic incantation that will convert the
 378              *  bit flag values back into a string suitable for printing.
 379              */
 380             (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD );
 381             if (pOD->optArg.argString != NULL) {
 382                 fputs(pOD->optArg.argString, fp);
 383
 384                 if (ovp->valType != OPARG_TYPE_ENUMERATION) {
 385                     /*
 386                      *  set membership strings get allocated
 387                      */
 388                     AGFREE( (void*)pOD->optArg.argString );
 389                 }
 390             }
 391
 392             pOD->optArg.argEnum = val;
 393             pOD->fOptState = opt_state;
 394             fprintf(fp, close_xml, ovp->pzName);
 395             break;
 396         }
 397         /* FALLTHROUGH */
 398
 399     case OPARG_TYPE_NUMERIC:
 400         fprintf(fp, numb_atr, ovp->pzName, ovp->v.longVal);
 401         break;
 402
 403     case OPARG_TYPE_BOOLEAN:
 404         fprintf(fp, bool_atr, ovp->pzName,
 405                 ovp->v.boolVal ? "true" : "false");
 406         break;
 407
 408     case OPARG_TYPE_HIERARCHY:
 409         printValueList(fp, ovp->pzName, ovp->v.nestVal);
 410         break;
 411     }
 412 }
 413
 414
 415 static void
 416 print_a_string(FILE * fp, char const * name, char const * pz)
 417 {
 418     static char const open_atr[]  = "<%s>";
 419
 420     fprintf(fp, open_atr, name);
 421     for (;;) {
 422         int ch = ((int)*(pz++)) & 0xFF;
 423
 424         switch (ch) {
 425         case NUL: goto string_done;
 426
 427         case '&':
 428         case '<':
 429         case '>':
 430 #if __GNUC__ >= 4
 431         case 1 ... (' ' - 1):
 432         case ('~' + 1) ... 0xFF:
 433 #endif
 434             emit_special_char(fp, ch);
 435             break;
 436
 437         default:
 438 #if __GNUC__ < 4
 439             if (  ((ch >= 1) && (ch <= (' ' - 1)))
 440                || ((ch >= ('~' + 1)) && (ch <= 0xFF)) ) {
 441                 emit_special_char(fp, ch);
 442                 break;
 443             }
 444 #endif
 445             putc(ch, fp);
 446         }
 447     } string_done:;
 448     fprintf(fp, close_xml, name);
 449 }
 450
 451
 452 static void
 453 printValueList(FILE * fp, char const * name, tArgList * al)
 454 {
 455     static int depth = 1;
 456
 457     int sp_ct;
 458     int opt_ct;
 459     void ** opt_list;
 460
 461     if (al == NULL)
 462         return;
 463     opt_ct   = al->useCt;
 464     opt_list = (void **)al->apzArgs;
 465
 466     if (opt_ct <= 0) {
 467         fprintf(fp, "<%s/>\n", name);
 468         return;
 469     }
 470
 471     fprintf(fp, "<%s type=nested>\n", name);
 472
 473     depth++;
 474     while (--opt_ct >= 0) {
 475         tOptionValue const * ovp = *(opt_list++);
 476
 477         print_a_value(fp, depth, NULL, ovp);
 478     }
 479     depth--;
 480
 481     for (sp_ct = depth; --sp_ct >= 0;)
 482         putc(' ', fp), putc(' ', fp);
 483     fprintf(fp, "</%s>\n", name);
 484 }
 485
 486
 487 static void
 488 printHierarchy(FILE * fp, tOptDesc * p)
 489 {
 490     int opt_ct;
 491     tArgList * al = p->optCookie;
 492     void ** opt_list;
 493
 494     if (al == NULL)
 495         return;
 496
 497     opt_ct   = al->useCt;
 498     opt_list = (void **)al->apzArgs;
 499
 500     if (opt_ct <= 0)
 501         return;
 502
 503     do  {
 504         tOptionValue const * base = *(opt_list++);
 505         tOptionValue const * ovp = optionGetValue(base, NULL);
 506
 507         if (ovp == NULL)
 508             continue;
 509
 510         fprintf(fp, "<%s type=nested>\n", p->pz_Name);
 511
 512         do  {
 513             print_a_value(fp, 1, p, ovp);
 514
 515         } while (ovp = optionNextValue(base, ovp),
 516                  ovp != NULL);
 517
 518         fprintf(fp, "</%s>\n", p->pz_Name);
 519     } while (--opt_ct > 0);
 520 }
 521
 522
 523 static FILE *
 524 openSaveFile( tOptions* pOpts )
 525 {
 526     FILE*     fp;
 527
 528     {
 529         int   free_name = 0;
 530         tCC*  pzFName = findFileName( pOpts, &free_name );
 531         if (pzFName == NULL)
 532             return NULL;
 533
 534         fp = fopen( pzFName, "w" FOPEN_BINARY_FLAG );
 535         if (fp == NULL) {
 536             fprintf( stderr, zWarn, pOpts->pzProgName );
 537             fprintf( stderr, zNoCreat, errno, strerror( errno ), pzFName );
 538             if (free_name)
 539                 AGFREE((void*) pzFName );
 540             return fp;
 541         }
 542
 543         if (free_name)
 544             AGFREE( (void*)pzFName );
 545     }
 546
 547     {
 548         char const*  pz = pOpts->pzUsageTitle;
 549         fputs( "#  ", fp );
 550         do { fputc( *pz, fp ); } while (*(pz++) != '\n');
 551     }
 552
 553     {
 554         time_t  timeVal = time( NULL );
 555         char*   pzTime  = ctime( &timeVal );
 556
 557         fprintf( fp, zPresetFile, pzTime );
 558 #ifdef HAVE_ALLOCATED_CTIME
 559         /*
 560          *  The return values for ctime(), localtime(), and gmtime()
 561          *  normally point to static data that is overwritten by each call.
 562          *  The test to detect allocated ctime, so we leak the memory.
 563          */
 564         AGFREE( (void*)pzTime );
 565 #endif
 566     }
 567
 568     return fp;
 569 }
 570
 571 static void
 572 printNoArgOpt(FILE * fp, tOptDesc * p, tOptDesc * pOD)
 573 {
 574     /*
 575      * The aliased to argument indicates whether or not the option
 576      * is "disabled".  However, the original option has the name
 577      * string, so we get that there, not with "p".
 578      */
 579     char const * pznm =
 580         (DISABLED_OPT( p )) ? pOD->pz_DisableName : pOD->pz_Name;
 581     /*
 582      *  If the option was disabled and the disablement name is NULL,
 583      *  then the disablement was caused by aliasing.
 584      *  Use the name as the string to emit.
 585      */
 586     if (pznm == NULL)
 587         pznm = pOD->pz_Name;
 588
 589     fprintf(fp, "%s\n", pznm);
 590 }
 591
 592 static void
 593 printStringArg(FILE * fp, tOptDesc * pOD)
 594 {
 595     if (pOD->fOptState & OPTST_STACKED) {
 596         tArgList*  pAL = (tArgList*)pOD->optCookie;
 597         int        uct = pAL->useCt;
 598         tCC**      ppz = pAL->apzArgs;
 599
 600         /*
 601          *  un-disable multiple copies of disabled options.
 602          */
 603         if (uct > 1)
 604             pOD->fOptState &= ~OPTST_DISABLED;
 605
 606         while (uct-- > 0)
 607             printEntry( fp, pOD, *(ppz++) );
 608     } else {
 609         printEntry( fp, pOD, pOD->optArg.argString );
 610     }
 611 }
 612
 613 static void
 614 printEnumArg(FILE * fp, tOptDesc * pOD)
 615 {
 616     uintptr_t val = pOD->optArg.argEnum;
 617
 618     /*
 619      *  This is a magic incantation that will convert the
 620      *  bit flag values back into a string suitable for printing.
 621      */
 622     (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);
 623     printEntry( fp, pOD, (void*)(pOD->optArg.argString));
 624
 625     pOD->optArg.argEnum = val;
 626 }
 627
 628 static void
 629 printSetMemberArg(FILE * fp, tOptDesc * pOD)
 630 {
 631     uintptr_t val = pOD->optArg.argEnum;
 632
 633     /*
 634      *  This is a magic incantation that will convert the
 635      *  bit flag values back into a string suitable for printing.
 636      */
 637     (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);
 638     printEntry( fp, pOD, (void*)(pOD->optArg.argString));
 639
 640     if (pOD->optArg.argString != NULL) {
 641         /*
 642          *  set membership strings get allocated
 643          */
 644         AGFREE( (void*)pOD->optArg.argString );
 645         pOD->fOptState &= ~OPTST_ALLOC_ARG;
 646     }
 647
 648     pOD->optArg.argEnum = val;
 649 }
 650
 651 static void
 652 printFileArg(FILE * fp, tOptDesc * pOD, tOptions* pOpts)
 653 {
 654     /*
 655      *  If the cookie is not NULL, then it has the file name, period.
 656      *  Otherwise, if we have a non-NULL string argument, then....
 657      */
 658     if (pOD->optCookie != NULL)
 659         printEntry(fp, pOD, pOD->optCookie);
 660
 661     else if (HAS_originalOptArgArray(pOpts)) {
 662         char const * orig =
 663             pOpts->originalOptArgArray[pOD->optIndex].argString;
 664
 665         if (pOD->optArg.argString == orig)
 666             return;
 667
 668         printEntry(fp, pOD, pOD->optArg.argString);
 669     }
 670 }
 671
 672
 673 /*=export_func  optionSaveFile
 674  *
 675  * what:  saves the option state to a file
 676  *
 677  * arg:   tOptions*,   pOpts,  program options descriptor
 678  *
 679  * doc:
 680  *
 681  * This routine will save the state of option processing to a file.  The name
 682  * of that file can be specified with the argument to the @code{--save-opts}
 683  * option, or by appending the @code{rcfile} attribute to the last
 684  * @code{homerc} attribute.  If no @code{rcfile} attribute was specified, it
 685  * will default to @code{.@i{programname}rc}.  If you wish to specify another
 686  * file, you should invoke the @code{SET_OPT_SAVE_OPTS( @i{filename} )} macro.
 687  *
 688  * The recommend usage is as follows:
 689  * @example
 690  *    optionProcess(&progOptions, argc, argv);
 691  *    if (i_want_a_non_standard_place_for_this)
 692  *        SET_OPT_SAVE_OPTS("myfilename");
 693  *    optionSaveFile(&progOptions);
 694  * @end example
 695  *
 696  * err:
 697  *
 698  * If no @code{homerc} file was specified, this routine will silently return
 699  * and do nothing.  If the output file cannot be created or updated, a message
 700  * will be printed to @code{stderr} and the routine will return.
 701 =*/
 702 void
 703 optionSaveFile( tOptions* pOpts )
 704 {
 705     tOptDesc* pOD;
 706     int       ct;
 707     FILE*     fp = openSaveFile(pOpts);
 708
 709     if (fp == NULL)
 710         return;
 711
 712     /*
 713      *  FOR each of the defined options, ...
 714      */
 715     ct  = pOpts->presetOptCt;
 716     pOD = pOpts->pOptDesc;
 717     do  {
 718         tOptDesc*  p;
 719
 720         /*
 721          *  IF    the option has not been defined
 722          *     OR it does not take an initialization value
 723          *     OR it is equivalenced to another option
 724          *  THEN continue (ignore it)
 725          *
 726          *  Equivalenced options get picked up when the equivalenced-to
 727          *  option is processed.
 728          */
 729         if (UNUSED_OPT( pOD ))
 730             continue;
 731
 732         if ((pOD->fOptState & OPTST_DO_NOT_SAVE_MASK) != 0)
 733             continue;
 734
 735         if (  (pOD->optEquivIndex != NO_EQUIVALENT)
 736            && (pOD->optEquivIndex != pOD->optIndex))
 737             continue;
 738
 739         /*
 740          *  The option argument data are found at the equivalenced-to option,
 741          *  but the actual option argument type comes from the original
 742          *  option descriptor.  Be careful!
 743          */
 744         p = ((pOD->fOptState & OPTST_EQUIVALENCE) != 0)
 745             ? (pOpts->pOptDesc + pOD->optActualIndex) : pOD;
 746
 747         switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
 748         case OPARG_TYPE_NONE:
 749             printNoArgOpt(fp, p, pOD);
 750             break;
 751
 752         case OPARG_TYPE_NUMERIC:
 753             printEntry( fp, p, (void*)(p->optArg.argInt));
 754             break;
 755
 756         case OPARG_TYPE_STRING:
 757             printStringArg(fp, p);
 758             break;
 759
 760         case OPARG_TYPE_ENUMERATION:
 761             printEnumArg(fp, p);
 762             break;
 763
 764         case OPARG_TYPE_MEMBERSHIP:
 765             printSetMemberArg(fp, p);
 766             break;
 767
 768         case OPARG_TYPE_BOOLEAN:
 769             printEntry( fp, p, p->optArg.argBool ? "true" : "false" );
 770             break;
 771
 772         case OPARG_TYPE_HIERARCHY:
 773             printHierarchy(fp, p);
 774             break;
 775
 776         case OPARG_TYPE_FILE:
 777             printFileArg(fp, p, pOpts);
 778             break;
 779
 780         default:
 781             break; /* cannot handle - skip it */
 782         }
 783     } while ( (pOD++), (--ct > 0));
 784
 785     fclose( fp );
 786 }
 787 /*
 788  * Local Variables:
 789  * mode: C
 790  * c-file-style: "stroustrup"
 791  * indent-tabs-mode: nil
 792  * End:
 793  * end of autoopts/save.c */