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

   1 /*      $NetBSD$        */
   2
   3
   4 /*
   5  *  usage.c  Id: f611ee45aa9aa8dc102b8acf6b4bc568c60fa99f
   6  * Time-stamp:      "2009-10-02 23:18:50 bkorb"
   7  *
   8  *  This module implements the default usage procedure for
   9  *  Automated Options.  It may be overridden, of course.
  10  *
  11  *  Sort options:
  12     --start=END-[S]TATIC-FORWARD --patt='^/\*($|[^:])' \
  13     --out=xx.c key='^[a-zA-Z0-9_]+\(' --trail='^/\*:' \
  14     --spac=2 --input=usage.c
  15  */
  16
  17 /*
  18  *  This file is part of AutoOpts, a companion to AutoGen.
  19  *  AutoOpts is free software.
  20  *  AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
  21  *
  22  *  AutoOpts is available under any one of two licenses.  The license
  23  *  in use must be one of these two and the choice is under the control
  24  *  of the user of the license.
  25  *
  26  *   The GNU Lesser General Public License, version 3 or later
  27  *      See the files "COPYING.lgplv3" and "COPYING.gplv3"
  28  *
  29  *   The Modified Berkeley Software Distribution License
  30  *      See the file "COPYING.mbsd"
  31  *
  32  *  These files have the following md5sums:
  33  *
  34  *  43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
  35  *  06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
  36  *  66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
  37  */
  38
  39 #define OPTPROC_L_N_S  (OPTPROC_LONGOPT | OPTPROC_SHORTOPT)
  40
  41 static arg_types_t argTypes;
  42
  43 FILE* option_usage_fp = NULL;
  44 static char    zOptFmtLine[ 16 ];
  45 static ag_bool displayEnum;
  46
  47 /* = = = START-STATIC-FORWARD = = = */
  48 /* static forward declarations maintained by mk-fwd */
  49 static ag_bool
  50 checkGNUUsage( tOptions* pOpts );
  51
  52 static void
  53 printExtendedUsage(
  54     tOptions*     pOptions,
  55     tOptDesc*     pOD,
  56     arg_types_t*  pAT );
  57
  58 static void
  59 printInitList(
  60     tCC* const* papz,
  61     ag_bool*    pInitIntro,
  62     tCC*        pzRc,
  63     tCC*        pzPN );
  64
  65 static void
  66 printOptPreamble(
  67     tOptions*     pOptions,
  68     tOptDesc*     pOD,
  69     arg_types_t*  pAT );
  70
  71 static void
  72 printOneUsage(
  73     tOptions*     pOptions,
  74     tOptDesc*     pOD,
  75     arg_types_t*  pAT );
  76
  77 static void
  78 printOptionUsage(
  79     tOptions *  pOpts,
  80     int         ex_code,
  81     tCC *       pOptTitle );
  82
  83 static void
  84 printProgramDetails( tOptions* pOptions );
  85
  86 static int
  87 setGnuOptFmts( tOptions* pOpts, tCC** ppT );
  88
  89 static int
  90 setStdOptFmts( tOptions* pOpts, tCC** ppT );
  91 /* = = = END-STATIC-FORWARD = = = */
  92
  93
  94 /*
  95  *  Figure out if we should try to format usage text sort-of like
  96  *  the way many GNU programs do.
  97  */
  98 static ag_bool
  99 checkGNUUsage( tOptions* pOpts )
 100 {
 101     char* pz = getenv( "AUTOOPTS_USAGE" );
 102     if (pz == NULL)
 103         ;
 104
 105     else if (streqvcmp( pz, "gnu" ) == 0)
 106         pOpts->fOptSet |= OPTPROC_GNUUSAGE;
 107
 108     else if (streqvcmp( pz, "autoopts" ) == 0)
 109         pOpts->fOptSet &= ~OPTPROC_GNUUSAGE;
 110
 111     return (pOpts->fOptSet & OPTPROC_GNUUSAGE) ? AG_TRUE : AG_FALSE;
 112 }
 113
 114
 115 /*=export_func  optionOnlyUsage
 116  *
 117  * what:  Print usage text for just the options
 118  * arg:   + tOptions*   + pOpts    + program options descriptor +
 119  * arg:   + int         + ex_code  + exit code for calling exit(3) +
 120  *
 121  * doc:
 122  *  This routine will print only the usage for each option.
 123  *  This function may be used when the emitted usage must incorporate
 124  *  information not available to AutoOpts.
 125 =*/
 126 void
 127 optionOnlyUsage(
 128     tOptions* pOpts,
 129     int       ex_code )
 130 {
 131     tCC* pOptTitle = NULL;
 132
 133     /*
 134      *  Determine which header and which option formatting strings to use
 135      */
 136     if (checkGNUUsage(pOpts)) {
 137         (void)setGnuOptFmts( pOpts, &pOptTitle );
 138     }
 139     else {
 140         (void)setStdOptFmts( pOpts, &pOptTitle );
 141     }
 142
 143     printOptionUsage( pOpts, ex_code, pOptTitle );
 144 }
 145
 146
 147 /*=export_func  optionUsage
 148  * private:
 149  *
 150  * what:  Print usage text
 151  * arg:   + tOptions* + pOptions + program options descriptor +
 152  * arg:   + int       + exitCode + exit code for calling exit(3) +
 153  *
 154  * doc:
 155  *  This routine will print usage in both GNU-standard and AutoOpts-expanded
 156  *  formats.  The descriptor specifies the default, but AUTOOPTS_USAGE will
 157  *  over-ride this, providing the value of it is set to either "gnu" or
 158  *  "autoopts".  This routine will @strong{not} return.
 159  *
 160  *  If "exitCode" is "EX_USAGE" (normally 64), then output will to to stdout
 161  *  and the actual exit code will be "EXIT_SUCCESS".
 162 =*/
 163 void
 164 optionUsage(
 165     tOptions* pOptions,
 166     int       usage_exit_code )
 167 {
 168     int actual_exit_code =
 169         (usage_exit_code == EX_USAGE) ? EXIT_SUCCESS : usage_exit_code;
 170
 171     displayEnum = AG_FALSE;
 172
 173     /*
 174      *  Paged usage will preset option_usage_fp to an output file.
 175      *  If it hasn't already been set, then set it to standard output
 176      *  on successful exit (help was requested), otherwise error out.
 177      *
 178      *  Test the version before obtaining pzFullUsage or pzShortUsage.
 179      *  These fields do not exist before revision 30.
 180      */
 181     {
 182         char const * pz;
 183
 184         if (actual_exit_code == EXIT_SUCCESS) {
 185             pz = (pOptions->structVersion >= 30 * 4096)
 186                 ? pOptions->pzFullUsage : NULL;
 187
 188             if (option_usage_fp == NULL)
 189                 option_usage_fp = stdout;
 190         } else {
 191             pz = (pOptions->structVersion >= 30 * 4096)
 192                 ? pOptions->pzShortUsage : NULL;
 193
 194             if (option_usage_fp == NULL)
 195                 option_usage_fp = stderr;
 196         }
 197
 198         if (pz != NULL) {
 199             fputs(pz, option_usage_fp);
 200             exit(actual_exit_code);
 201         }
 202     }
 203
 204     fprintf( option_usage_fp, pOptions->pzUsageTitle, pOptions->pzProgName );
 205
 206     {
 207         tCC* pOptTitle = NULL;
 208
 209         /*
 210          *  Determine which header and which option formatting strings to use
 211          */
 212         if (checkGNUUsage(pOptions)) {
 213             int flen = setGnuOptFmts( pOptions, &pOptTitle );
 214             sprintf( zOptFmtLine, zFmtFmt, flen );
 215             fputc( '\n', option_usage_fp );
 216         }
 217         else {
 218             int flen = setStdOptFmts( pOptions, &pOptTitle );
 219             sprintf( zOptFmtLine, zFmtFmt, flen );
 220
 221             /*
 222              *  When we exit with EXIT_SUCCESS and the first option is a doc
 223              *  option, we do *NOT* want to emit the column headers.
 224              *  Otherwise, we do.
 225              */
 226             if (  (usage_exit_code != EXIT_SUCCESS)
 227                || ((pOptions->pOptDesc->fOptState & OPTST_DOCUMENT) == 0) )
 228
 229                 fputs( pOptTitle, option_usage_fp );
 230         }
 231
 232         printOptionUsage( pOptions, usage_exit_code, pOptTitle );
 233     }
 234
 235     /*
 236      *  Describe the mechanics of denoting the options
 237      */
 238     switch (pOptions->fOptSet & OPTPROC_L_N_S) {
 239     case OPTPROC_L_N_S:     fputs( zFlagOkay, option_usage_fp ); break;
 240     case OPTPROC_SHORTOPT:  break;
 241     case OPTPROC_LONGOPT:   fputs( zNoFlags,  option_usage_fp ); break;
 242     case 0:                 fputs( zOptsOnly, option_usage_fp ); break;
 243     }
 244
 245     if ((pOptions->fOptSet & OPTPROC_NUM_OPT) != 0) {
 246         fputs( zNumberOpt, option_usage_fp );
 247     }
 248
 249     if ((pOptions->fOptSet & OPTPROC_REORDER) != 0) {
 250         fputs( zReorder, option_usage_fp );
 251     }
 252
 253     if (pOptions->pzExplain != NULL)
 254         fputs( pOptions->pzExplain, option_usage_fp );
 255
 256     /*
 257      *  IF the user is asking for help (thus exiting with SUCCESS),
 258      *  THEN see what additional information we can provide.
 259      */
 260     if (usage_exit_code == EXIT_SUCCESS)
 261         printProgramDetails( pOptions );
 262
 263     if (pOptions->pzBugAddr != NULL)
 264         fprintf( option_usage_fp, zPlsSendBugs, pOptions->pzBugAddr );
 265     fflush( option_usage_fp );
 266
 267     exit( actual_exit_code );
 268 }
 269
 270
 271 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 272  *
 273  *   PER OPTION TYPE USAGE INFORMATION
 274  */
 275 static void
 276 printExtendedUsage(
 277     tOptions*     pOptions,
 278     tOptDesc*     pOD,
 279     arg_types_t*  pAT )
 280 {
 281     /*
 282      *  IF there are option conflicts or dependencies,
 283      *  THEN print them here.
 284      */
 285     if (  (pOD->pOptMust != NULL)
 286        || (pOD->pOptCant != NULL) ) {
 287
 288         fputs( zTabHyp, option_usage_fp );
 289
 290         /*
 291          *  DEPENDENCIES:
 292          */
 293         if (pOD->pOptMust != NULL) {
 294             const int* pOptNo = pOD->pOptMust;
 295
 296             fputs( zReqThese, option_usage_fp );
 297             for (;;) {
 298                 fprintf( option_usage_fp, zTabout, pOptions->pOptDesc[
 299                              *pOptNo ].pz_Name );
 300                 if (*++pOptNo == NO_EQUIVALENT)
 301                     break;
 302             }
 303
 304             if (pOD->pOptCant != NULL)
 305                 fputs( zTabHypAnd, option_usage_fp );
 306         }
 307
 308         /*
 309          *  CONFLICTS:
 310          */
 311         if (pOD->pOptCant != NULL) {
 312             const int* pOptNo = pOD->pOptCant;
 313
 314             fputs( zProhib, option_usage_fp );
 315             for (;;) {
 316                 fprintf( option_usage_fp, zTabout, pOptions->pOptDesc[
 317                              *pOptNo ].pz_Name );
 318                 if (*++pOptNo == NO_EQUIVALENT)
 319                     break;
 320             }
 321         }
 322     }
 323
 324     /*
 325      *  IF there is a disablement string
 326      *  THEN print the disablement info
 327      */
 328     if (pOD->pz_DisableName != NULL )
 329         fprintf( option_usage_fp, zDis, pOD->pz_DisableName );
 330
 331     /*
 332      *  Check for argument types that have callbacks with magical properties
 333      */
 334     switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
 335     case OPARG_TYPE_NUMERIC:
 336         /*
 337          *  IF the numeric option has a special callback,
 338          *  THEN call it, requesting the range or other special info
 339          */
 340         if (  (pOD->pOptProc != NULL)
 341            && (pOD->pOptProc != optionNumericVal) ) {
 342             (*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
 343         }
 344         break;
 345
 346     case OPARG_TYPE_FILE:
 347         (*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
 348         break;
 349     }
 350
 351     /*
 352      *  IF the option defaults to being enabled,
 353      *  THEN print that out
 354      */
 355     if (pOD->fOptState & OPTST_INITENABLED)
 356         fputs( zEnab, option_usage_fp );
 357
 358     /*
 359      *  IF  the option is in an equivalence class
 360      *        AND not the designated lead
 361      *  THEN print equivalence and leave it at that.
 362      */
 363     if (  (pOD->optEquivIndex != NO_EQUIVALENT)
 364        && (pOD->optEquivIndex != pOD->optActualIndex )  )  {
 365         fprintf( option_usage_fp, zAlt,
 366                  pOptions->pOptDesc[ pOD->optEquivIndex ].pz_Name );
 367         return;
 368     }
 369
 370     /*
 371      *  IF this particular option can NOT be preset
 372      *    AND some form of presetting IS allowed,
 373      *    AND it is not an auto-managed option (e.g. --help, et al.)
 374      *  THEN advise that this option may not be preset.
 375      */
 376     if (  ((pOD->fOptState & OPTST_NO_INIT) != 0)
 377        && (  (pOptions->papzHomeList != NULL)
 378           || (pOptions->pzPROGNAME != NULL)
 379           )
 380        && (pOD->optIndex < pOptions->presetOptCt)
 381        )
 382
 383         fputs( zNoPreset, option_usage_fp );
 384
 385     /*
 386      *  Print the appearance requirements.
 387      */
 388     if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP)
 389         fputs( zMembers, option_usage_fp );
 390
 391     else switch (pOD->optMinCt) {
 392     case 1:
 393     case 0:
 394         switch (pOD->optMaxCt) {
 395         case 0:       fputs( zPreset, option_usage_fp ); break;
 396         case NOLIMIT: fputs( zNoLim, option_usage_fp );  break;
 397         case 1:       break;
 398             /*
 399              * IF the max is more than one but limited, print "UP TO" message
 400              */
 401         default:      fprintf( option_usage_fp, zUpTo, pOD->optMaxCt );  break;
 402         }
 403         break;
 404
 405     default:
 406         /*
 407          *  More than one is required.  Print the range.
 408          */
 409         fprintf( option_usage_fp, zMust, pOD->optMinCt, pOD->optMaxCt );
 410     }
 411
 412     if (  NAMED_OPTS( pOptions )
 413        && (pOptions->specOptIdx.default_opt == pOD->optIndex))
 414         fputs( zDefaultOpt, option_usage_fp );
 415 }
 416
 417
 418 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 419  *
 420  *   Figure out where all the initialization files might live.
 421  *   This requires translating some environment variables and
 422  *   testing to see if a name is a directory or a file.  It's
 423  *   squishy, but important to tell users how to find these files.
 424  */
 425 static void
 426 printInitList(
 427     tCC* const* papz,
 428     ag_bool*    pInitIntro,
 429     tCC*        pzRc,
 430     tCC*        pzPN )
 431 {
 432     char zPath[ AG_PATH_MAX+1 ];
 433
 434     if (papz == NULL)
 435         return;
 436
 437     fputs( zPresetIntro, option_usage_fp );
 438     *pInitIntro = AG_FALSE;
 439
 440     for (;;) {
 441         char const* pzPath = *(papz++);
 442
 443         if (pzPath == NULL)
 444             break;
 445
 446         if (optionMakePath(zPath, (int)sizeof( zPath ), pzPath, pzPN))
 447             pzPath = zPath;
 448
 449         /*
 450          *  Print the name of the "homerc" file.  If the "rcfile" name is
 451          *  not empty, we may or may not print that, too...
 452          */
 453         fprintf( option_usage_fp, zPathFmt, pzPath );
 454         if (*pzRc != NUL) {
 455             struct stat sb;
 456
 457             /*
 458              *  IF the "homerc" file is a directory,
 459              *  then append the "rcfile" name.
 460              */
 461             if (  (stat( pzPath, &sb ) == 0)
 462               &&  S_ISDIR( sb.st_mode ) ) {
 463                 fputc( DIRCH, option_usage_fp );
 464                 fputs( pzRc, option_usage_fp );
 465             }
 466         }
 467
 468         fputc( '\n', option_usage_fp );
 469     }
 470 }
 471
 472
 473 static void
 474 printOptPreamble(
 475     tOptions*     pOptions,
 476     tOptDesc*     pOD,
 477     arg_types_t*  pAT )
 478 {
 479     /*
 480      *  Flag prefix: IF no flags at all, then omit it.  If not printable
 481      *  (not allowed for this option), then blank, else print it.
 482      *  Follow it with a comma if we are doing GNU usage and long
 483      *  opts are to be printed too.
 484      */
 485     if ((pOptions->fOptSet & OPTPROC_SHORTOPT) == 0)
 486         fputs( pAT->pzSpc, option_usage_fp );
 487
 488     else if (! IS_GRAPHIC_CHAR(pOD->optValue)) {
 489         if (  (pOptions->fOptSet & (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
 490            == (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
 491             fputc( ' ', option_usage_fp );
 492         fputs( pAT->pzNoF, option_usage_fp );
 493
 494     } else {
 495         fprintf( option_usage_fp, "   -%c", pOD->optValue );
 496         if (  (pOptions->fOptSet & (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
 497            == (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
 498             fputs( ", ", option_usage_fp );
 499     }
 500 }
 501
 502 /*
 503  *  Print the usage information for a single option.
 504  */
 505 static void
 506 printOneUsage(
 507     tOptions*     pOptions,
 508     tOptDesc*     pOD,
 509     arg_types_t*  pAT )
 510 {
 511     printOptPreamble(pOptions, pOD, pAT);
 512
 513     {
 514         char  z[ 80 ];
 515         tCC*  pzArgType;
 516         /*
 517          *  Determine the argument type string first on its usage, then,
 518          *  when the option argument is required, base the type string on the
 519          *  argument type.
 520          */
 521         if (pOD->fOptState & OPTST_ARG_OPTIONAL) {
 522             pzArgType = pAT->pzOpt;
 523
 524         } else switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
 525         case OPARG_TYPE_NONE:        pzArgType = pAT->pzNo;   break;
 526         case OPARG_TYPE_ENUMERATION: pzArgType = pAT->pzKey;  break;
 527         case OPARG_TYPE_FILE       : pzArgType = pAT->pzFile; break;
 528         case OPARG_TYPE_MEMBERSHIP:  pzArgType = pAT->pzKeyL; break;
 529         case OPARG_TYPE_BOOLEAN:     pzArgType = pAT->pzBool; break;
 530         case OPARG_TYPE_NUMERIC:     pzArgType = pAT->pzNum;  break;
 531         case OPARG_TYPE_HIERARCHY:   pzArgType = pAT->pzNest; break;
 532         case OPARG_TYPE_STRING:      pzArgType = pAT->pzStr;  break;
 533         case OPARG_TYPE_TIME:        pzArgType = pAT->pzTime; break;
 534         default:                     goto bogus_desc;
 535         }
 536
 537         snprintf( z, sizeof(z), pAT->pzOptFmt, pzArgType, pOD->pz_Name,
 538                   (pOD->optMinCt != 0) ? pAT->pzReq : pAT->pzOpt );
 539
 540         fprintf( option_usage_fp, zOptFmtLine, z, pOD->pzText );
 541
 542         switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
 543         case OPARG_TYPE_ENUMERATION:
 544         case OPARG_TYPE_MEMBERSHIP:
 545             displayEnum = (pOD->pOptProc != NULL) ? AG_TRUE : displayEnum;
 546         }
 547     }
 548     return;
 549
 550  bogus_desc:
 551     fprintf( stderr, zInvalOptDesc, pOD->pz_Name );
 552     exit( EX_SOFTWARE );
 553 }
 554
 555
 556 /*
 557  *  Print out the usage information for just the options.
 558  */
 559 static void
 560 printOptionUsage(
 561     tOptions *  pOpts,
 562     int         ex_code,
 563     tCC *       pOptTitle )
 564 {
 565     int         ct     = pOpts->optCt;
 566     int         optNo  = 0;
 567     tOptDesc *  pOD    = pOpts->pOptDesc;
 568     int         docCt  = 0;
 569
 570     do  {
 571         if ((pOD->fOptState & OPTST_NO_USAGE_MASK) != 0) {
 572
 573             /*
 574              * IF      this is a compiled-out option
 575              *   *AND* usage was requested with "omitted-usage"
 576              *   *AND* this is NOT abbreviated usage
 577              * THEN display this option.
 578              */
 579             if (  (pOD->fOptState == (OPTST_OMITTED | OPTST_NO_INIT))
 580                && (pOD->pz_Name != NULL)
 581                && (ex_code == EXIT_SUCCESS))  {
 582
 583                 char const * why_pz =
 584                     (pOD->pzText == NULL) ? zDisabledWhy : pOD->pzText;
 585                 printOptPreamble(pOpts, pOD, &argTypes);
 586                 fprintf(option_usage_fp, zDisabledOpt, pOD->pz_Name, why_pz);
 587             }
 588
 589             continue;
 590         }
 591
 592         if ((pOD->fOptState & OPTST_DOCUMENT) != 0) {
 593             if (ex_code == EXIT_SUCCESS) {
 594                 fprintf(option_usage_fp, argTypes.pzBrk, pOD->pzText,
 595                         pOptTitle);
 596                 docCt++;
 597             }
 598
 599             continue;
 600         }
 601
 602         /*
 603          *  IF       this is the first auto-opt maintained option
 604          *    *AND*  we are doing a full help
 605          *    *AND*  there are documentation options
 606          *    *AND*  the last one was not a doc option,
 607          *  THEN document that the remaining options are not user opts
 608          */
 609         if (  (pOpts->presetOptCt == optNo)
 610            && (ex_code == EXIT_SUCCESS)
 611            && (docCt > 0)
 612            && ((pOD[-1].fOptState & OPTST_DOCUMENT) == 0) )
 613             fprintf( option_usage_fp, argTypes.pzBrk, zAuto, pOptTitle );
 614
 615         printOneUsage(pOpts, pOD, &argTypes);
 616
 617         /*
 618          *  IF we were invoked because of the --help option,
 619          *  THEN print all the extra info
 620          */
 621         if (ex_code == EXIT_SUCCESS)
 622             printExtendedUsage( pOpts, pOD, &argTypes );
 623
 624     }  while (pOD++, optNo++, (--ct > 0));
 625
 626     fputc( '\n', option_usage_fp );
 627 }
 628
 629
 630 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 631  *
 632  *   PROGRAM DETAILS
 633  */
 634 static void
 635 printProgramDetails( tOptions* pOptions )
 636 {
 637     ag_bool  initIntro = AG_TRUE;
 638
 639     /*
 640      *  Display all the places we look for config files
 641      */
 642     printInitList( pOptions->papzHomeList, &initIntro,
 643                    pOptions->pzRcName, pOptions->pzProgPath );
 644
 645     /*
 646      *  Let the user know about environment variable settings
 647      */
 648     if ((pOptions->fOptSet & OPTPROC_ENVIRON) != 0) {
 649         if (initIntro)
 650             fputs( zPresetIntro, option_usage_fp );
 651
 652         fprintf( option_usage_fp, zExamineFmt, pOptions->pzPROGNAME );
 653     }
 654
 655     /*
 656      *  IF we found an enumeration,
 657      *  THEN hunt for it again.  Call the handler proc with a NULL
 658      *       option struct pointer.  That tells it to display the keywords.
 659      */
 660     if (displayEnum) {
 661         int        ct     = pOptions->optCt;
 662         int        optNo  = 0;
 663         tOptDesc*  pOD    = pOptions->pOptDesc;
 664
 665         fputc( '\n', option_usage_fp );
 666         fflush( option_usage_fp );
 667         do  {
 668             switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
 669             case OPARG_TYPE_ENUMERATION:
 670             case OPARG_TYPE_MEMBERSHIP:
 671                 (*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
 672             }
 673         }  while (pOD++, optNo++, (--ct > 0));
 674     }
 675
 676     /*
 677      *  If there is a detail string, now is the time for that.
 678      */
 679     if (pOptions->pzDetail != NULL)
 680         fputs( pOptions->pzDetail, option_usage_fp );
 681 }
 682
 683
 684 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 685  *
 686  *   OPTION LINE FORMATTING SETUP
 687  *
 688  *  The "OptFmt" formats receive three arguments:
 689  *  1.  the type of the option's argument
 690  *  2.  the long name of the option
 691  *  3.  "YES" or "no ", depending on whether or not the option must appear
 692  *      on the command line.
 693  *  These formats are used immediately after the option flag (if used) has
 694  *  been printed.
 695  *
 696  *  Set up the formatting for GNU-style output
 697  */
 698 static int
 699 setGnuOptFmts( tOptions* pOpts, tCC** ppT )
 700 {
 701     int  flen = 22;
 702     *ppT = zNoRq_ShrtTtl;
 703
 704     argTypes.pzStr  = zGnuStrArg;
 705     argTypes.pzReq  = zOneSpace;
 706     argTypes.pzNum  = zGnuNumArg;
 707     argTypes.pzKey  = zGnuKeyArg;
 708     argTypes.pzKeyL = zGnuKeyLArg;
 709     argTypes.pzTime = zGnuTimeArg;
 710     argTypes.pzFile = zGnuFileArg;
 711     argTypes.pzBool = zGnuBoolArg;
 712     argTypes.pzNest = zGnuNestArg;
 713     argTypes.pzOpt  = zGnuOptArg;
 714     argTypes.pzNo   = zOneSpace;
 715     argTypes.pzBrk  = zGnuBreak;
 716     argTypes.pzNoF  = zSixSpaces;
 717     argTypes.pzSpc  = zThreeSpaces;
 718
 719     switch (pOpts->fOptSet & OPTPROC_L_N_S) {
 720     case OPTPROC_L_N_S:    argTypes.pzOptFmt = zGnuOptFmt;     break;
 721     case OPTPROC_LONGOPT:  argTypes.pzOptFmt = zGnuOptFmt;     break;
 722     case 0:                argTypes.pzOptFmt = zGnuOptFmt + 2; break;
 723     case OPTPROC_SHORTOPT:
 724         argTypes.pzOptFmt = zShrtGnuOptFmt;
 725         zGnuStrArg[0] = zGnuNumArg[0] = zGnuKeyArg[0] = zGnuBoolArg[0] = ' ';
 726         argTypes.pzOpt = " [arg]";
 727         flen = 8;
 728         break;
 729     }
 730
 731     return flen;
 732 }
 733
 734
 735 /*
 736  *  Standard (AutoOpts normal) option line formatting
 737  */
 738 static int
 739 setStdOptFmts( tOptions* pOpts, tCC** ppT )
 740 {
 741     int  flen = 0;
 742
 743     argTypes.pzStr  = zStdStrArg;
 744     argTypes.pzReq  = zStdReqArg;
 745     argTypes.pzNum  = zStdNumArg;
 746     argTypes.pzKey  = zStdKeyArg;
 747     argTypes.pzKeyL = zStdKeyLArg;
 748     argTypes.pzTime = zStdTimeArg;
 749     argTypes.pzFile = zStdFileArg;
 750     argTypes.pzBool = zStdBoolArg;
 751     argTypes.pzNest = zStdNestArg;
 752     argTypes.pzOpt  = zStdOptArg;
 753     argTypes.pzNo   = zStdNoArg;
 754     argTypes.pzBrk  = zStdBreak;
 755     argTypes.pzNoF  = zFiveSpaces;
 756     argTypes.pzSpc  = zTwoSpaces;
 757
 758     switch (pOpts->fOptSet & (OPTPROC_NO_REQ_OPT | OPTPROC_SHORTOPT)) {
 759     case (OPTPROC_NO_REQ_OPT | OPTPROC_SHORTOPT):
 760         *ppT = zNoRq_ShrtTtl;
 761         argTypes.pzOptFmt = zNrmOptFmt;
 762         flen = 19;
 763         break;
 764
 765     case OPTPROC_NO_REQ_OPT:
 766         *ppT = zNoRq_NoShrtTtl;
 767         argTypes.pzOptFmt = zNrmOptFmt;
 768         flen = 19;
 769         break;
 770
 771     case OPTPROC_SHORTOPT:
 772         *ppT = zReq_ShrtTtl;
 773         argTypes.pzOptFmt = zReqOptFmt;
 774         flen = 24;
 775         break;
 776
 777     case 0:
 778         *ppT = zReq_NoShrtTtl;
 779         argTypes.pzOptFmt = zReqOptFmt;
 780         flen = 24;
 781     }
 782
 783     return flen;
 784 }
 785
 786
 787 /*:
 788  * Local Variables:
 789  * mode: C
 790  * c-file-style: "stroustrup"
 791  * indent-tabs-mode: nil
 792  * End:
 793  * end of autoopts/usage.c */