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

   1 /*      $NetBSD$        */
   2
   3
   4 /*
   5  *  Id: 7226344c6486a4eda395f893881080b7d80a2003
   6  * Time-stamp:      "2009-11-01 11:52:37 bkorb"
   7  *
   8  *  This module will interpret the options set in the tOptions
   9  *  structure and create a Bourne shell script capable of parsing them.
  10  *
  11  *  This file is part of AutoOpts, a companion to AutoGen.
  12  *  AutoOpts is free software.
  13  *  AutoOpts is copyright (c) 1992-2009 by Bruce Korb - all rights reserved
  14  *
  15  *  AutoOpts is available under any one of two licenses.  The license
  16  *  in use must be one of these two and the choice is under the control
  17  *  of the user of the license.
  18  *
  19  *   The GNU Lesser General Public License, version 3 or later
  20  *      See the files "COPYING.lgplv3" and "COPYING.gplv3"
  21  *
  22  *   The Modified Berkeley Software Distribution License
  23  *      See the file "COPYING.mbsd"
  24  *
  25  *  These files have the following md5sums:
  26  *
  27  *  43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
  28  *  06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
  29  *  66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
  30  */
  31
  32 tOptions*  pShellParseOptions = NULL;
  33
  34 /* * * * * * * * * * * * * * * * * * * * *
  35  *
  36  *  Setup Format Strings
  37  */
  38 static char const zStartMarker[] =
  39 "# # # # # # # # # # -- do not modify this marker --\n#\n"
  40 "#  DO NOT EDIT THIS SECTION";
  41
  42 static char const zPreamble[] =
  43 "%s OF %s\n#\n"
  44 "#  From here to the next `-- do not modify this marker --',\n"
  45 "#  the text has been generated %s\n";
  46
  47 static char const zEndPreamble[] =
  48 "#  From the %s option definitions\n#\n";
  49
  50 static char const zMultiDef[] = "\n"
  51 "if test -z \"${%1$s_%2$s}\"\n"
  52 "then\n"
  53 "  %1$s_%2$s_CT=0\n"
  54 "else\n"
  55 "  %1$s_%2$s_CT=1\n"
  56 "  %1$s_%2$s_1=\"${%1$s_%2$s}\"\n"
  57 "fi\n"
  58 "export %1$s_%2$s_CT";
  59
  60 static char const zSingleDef[] = "\n"
  61 "%1$s_%2$s=\"${%1$s_%2$s-'%3$s'}\"\n"
  62 "%1$s_%2$s_set=false\n"
  63 "export %1$s_%2$s\n";
  64
  65 static char const zSingleNoDef[] = "\n"
  66 "%1$s_%2$s=\"${%1$s_%2$s}\"\n"
  67 "%1$s_%2$s_set=false\n"
  68 "export %1$s_%2$s\n";
  69
  70 /* * * * * * * * * * * * * * * * * * * * *
  71  *
  72  *  LOOP START
  73  *
  74  *  The loop may run in either of two modes:
  75  *  all options are named options (loop only)
  76  *  regular, marked option processing.
  77  */
  78 static char const zLoopCase[] = "\n"
  79 "OPT_PROCESS=true\n"
  80 "OPT_ARG=\"$1\"\n\n"
  81 "while ${OPT_PROCESS} && [ $# -gt 0 ]\ndo\n"
  82 "    OPT_ELEMENT=''\n"
  83 "    OPT_ARG_VAL=''\n\n"
  84      /*
  85       *  'OPT_ARG' may or may not match the current $1
  86       */
  87 "    case \"${OPT_ARG}\" in\n"
  88 "    -- )\n"
  89 "        OPT_PROCESS=false\n"
  90 "        shift\n"
  91 "        ;;\n\n";
  92
  93 static char const zLoopOnly[] = "\n"
  94 "OPT_ARG=\"$1\"\n\n"
  95 "while [ $# -gt 0 ]\ndo\n"
  96 "    OPT_ELEMENT=''\n"
  97 "    OPT_ARG_VAL=''\n\n"
  98 "    OPT_ARG=\"${1}\"\n";
  99
 100 /* * * * * * * * * * * * * * * *
 101  *
 102  *  CASE SELECTORS
 103  *
 104  *  If the loop runs as a regular option loop,
 105  *  then we must have selectors for each acceptable option
 106  *  type (long option, flag character and non-option)
 107  */
 108 static char const zLongSelection[] =
 109 "    --* )\n";
 110
 111 static char const zFlagSelection[] =
 112 "    -* )\n";
 113
 114 static char const zEndSelection[] =
 115 "        ;;\n\n";
 116
 117 static char const zNoSelection[] =
 118 "    * )\n"
 119 "         OPT_PROCESS=false\n"
 120 "         ;;\n"
 121 "    esac\n\n";
 122
 123 /* * * * * * * * * * * * * * * *
 124  *
 125  *  LOOP END
 126  */
 127 static char const zLoopEnd[] =
 128 "    if [ -n \"${OPT_ARG_VAL}\" ]\n"
 129 "    then\n"
 130 "        eval %1$s_${OPT_NAME}${OPT_ELEMENT}=\"'${OPT_ARG_VAL}'\"\n"
 131 "        export %1$s_${OPT_NAME}${OPT_ELEMENT}\n"
 132 "    fi\n"
 133 "done\n\n"
 134 "unset OPT_PROCESS || :\n"
 135 "unset OPT_ELEMENT || :\n"
 136 "unset OPT_ARG || :\n"
 137 "unset OPT_ARG_NEEDED || :\n"
 138 "unset OPT_NAME || :\n"
 139 "unset OPT_CODE || :\n"
 140 "unset OPT_ARG_VAL || :\n%2$s";
 141
 142 static char const zTrailerMarker[] = "\n"
 143 "# # # # # # # # # #\n#\n"
 144 "#  END OF AUTOMATED OPTION PROCESSING\n"
 145 "#\n# # # # # # # # # # -- do not modify this marker --\n";
 146
 147 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 148  *
 149  *  OPTION SELECTION
 150  */
 151 static char const zOptionCase[] =
 152 "        case \"${OPT_CODE}\" in\n";
 153
 154 static char const zOptionPartName[] =
 155 "        '%s' | \\\n";
 156
 157 static char const zOptionFullName[] =
 158 "        '%s' )\n";
 159
 160 static char const zOptionFlag[] =
 161 "        '%c' )\n";
 162
 163 static char const zOptionEndSelect[] =
 164 "            ;;\n\n";
 165
 166 static char const zOptionUnknown[] =
 167 "        * )\n"
 168 "            echo Unknown %s: \"${OPT_CODE}\" >&2\n"
 169 "            echo \"$%s_USAGE_TEXT\"\n"
 170 "            exit 1\n"
 171 "            ;;\n"
 172 "        esac\n\n";
 173
 174 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 175  *
 176  *  OPTION PROCESSING
 177  *
 178  *  Formats for emitting the text for handling particular options
 179  */
 180 static char const zTextExit[] =
 181 "            echo \"$%s_%s_TEXT\"\n"
 182 "            exit 0\n";
 183
 184 static char const zPagedUsageExit[] =
 185 "            echo \"$%s_LONGUSAGE_TEXT\" | ${PAGER-more}\n"
 186 "            exit 0\n";
 187
 188 static char const zCmdFmt[] =
 189 "            %s\n";
 190
 191 static char const zCountTest[] =
 192 "            if [ $%1$s_%2$s_CT -ge %3$d ] ; then\n"
 193 "                echo Error:  more than %3$d %2$s options >&2\n"
 194 "                echo \"$%1$s_USAGE_TEXT\"\n"
 195 "                exit 1 ; fi\n";
 196
 197 static char const zMultiArg[] =
 198 "            %1$s_%2$s_CT=`expr ${%1$s_%2$s_CT} + 1`\n"
 199 "            OPT_ELEMENT=\"_${%1$s_%2$s_CT}\"\n"
 200 "            OPT_NAME='%2$s'\n";
 201
 202 static char const zSingleArg[] =
 203 "            if [ -n \"${%1$s_%2$s}\" ] && ${%1$s_%2$s_set} ; then\n"
 204 "                echo Error:  duplicate %2$s option >&2\n"
 205 "                echo \"$%1$s_USAGE_TEXT\"\n"
 206 "                exit 1 ; fi\n"
 207 "            %1$s_%2$s_set=true\n"
 208 "            OPT_NAME='%2$s'\n";
 209
 210 static char const zNoMultiArg[] =
 211 "            %1$s_%2$s_CT=0\n"
 212 "            OPT_ELEMENT=''\n"
 213 "            %1$s_%2$s='%3$s'\n"
 214 "            export %1$s_%2$s\n"
 215 "            OPT_NAME='%2$s'\n";
 216
 217 static char const zNoSingleArg[] =
 218 "            if [ -n \"${%1$s_%2$s}\" ] && ${%1$s_%2$s_set} ; then\n"
 219 "                echo Error:  duplicate %2$s option >&2\n"
 220 "                echo \"$%1$s_USAGE_TEXT\"\n"
 221 "                exit 1 ; fi\n"
 222 "            %1$s_%2$s_set=true\n"
 223 "            %1$s_%2$s='%3$s'\n"
 224 "            export %1$s_%2$s\n"
 225 "            OPT_NAME='%2$s'\n";
 226
 227 static char const zMayArg[]  =
 228 "            eval %1$s_%2$s${OPT_ELEMENT}=true\n"
 229 "            export %1$s_%2$s${OPT_ELEMENT}\n"
 230 "            OPT_ARG_NEEDED=OK\n";
 231
 232 static char const zMustArg[] =
 233 "            OPT_ARG_NEEDED=YES\n";
 234
 235 static char const zCantArg[] =
 236 "            eval %1$s_%2$s${OPT_ELEMENT}=true\n"
 237 "            export %1$s_%2$s${OPT_ELEMENT}\n"
 238 "            OPT_ARG_NEEDED=NO\n";
 239
 240 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 241  *
 242  *  LONG OPTION PROCESSING
 243  *
 244  *  Formats for emitting the text for handling long option types
 245  */
 246 static char const zLongOptInit[] =
 247 "        OPT_CODE=`echo \"X${OPT_ARG}\"|sed 's/^X-*//'`\n"
 248 "        shift\n"
 249 "        OPT_ARG=\"$1\"\n\n"
 250 "        case \"${OPT_CODE}\" in *=* )\n"
 251 "            OPT_ARG_VAL=`echo \"${OPT_CODE}\"|sed 's/^[^=]*=//'`\n"
 252 "            OPT_CODE=`echo \"${OPT_CODE}\"|sed 's/=.*$//'` ;; esac\n\n";
 253
 254 static char const zLongOptArg[] =
 255 "        case \"${OPT_ARG_NEEDED}\" in\n"
 256 "        NO )\n"
 257 "            OPT_ARG_VAL=''\n"
 258 "            ;;\n\n"
 259 "        YES )\n"
 260 "            if [ -z \"${OPT_ARG_VAL}\" ]\n"
 261 "            then\n"
 262 "                if [ $# -eq 0 ]\n"
 263 "                then\n"
 264 "                    echo No argument provided for ${OPT_NAME} option >&2\n"
 265 "                    echo \"$%s_USAGE_TEXT\"\n"
 266 "                    exit 1\n"
 267 "                fi\n\n"
 268 "                OPT_ARG_VAL=\"${OPT_ARG}\"\n"
 269 "                shift\n"
 270 "                OPT_ARG=\"$1\"\n"
 271 "            fi\n"
 272 "            ;;\n\n"
 273 "        OK )\n"
 274 "            if [ -z \"${OPT_ARG_VAL}\" ] && [ $# -gt 0 ]\n"
 275 "            then\n"
 276 "                case \"${OPT_ARG}\" in -* ) ;; * )\n"
 277 "                    OPT_ARG_VAL=\"${OPT_ARG}\"\n"
 278 "                    shift\n"
 279 "                    OPT_ARG=\"$1\" ;; esac\n"
 280 "            fi\n"
 281 "            ;;\n"
 282 "        esac\n";
 283
 284 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 285  *
 286  *  FLAG OPTION PROCESSING
 287  *
 288  *  Formats for emitting the text for handling flag option types
 289  */
 290 static char const zFlagOptInit[] =
 291 "        OPT_CODE=`echo \"X${OPT_ARG}\" | sed 's/X-\\(.\\).*/\\1/'`\n"
 292 "        OPT_ARG=` echo \"X${OPT_ARG}\" | sed 's/X-.//'`\n\n";
 293
 294 static char const zFlagOptArg[] =
 295 "        case \"${OPT_ARG_NEEDED}\" in\n"
 296 "        NO )\n"
 297 "            if [ -n \"${OPT_ARG}\" ]\n"
 298 "            then\n"
 299 "                OPT_ARG=-\"${OPT_ARG}\"\n"
 300 "            else\n"
 301 "                shift\n"
 302 "                OPT_ARG=\"$1\"\n"
 303 "            fi\n"
 304 "            ;;\n\n"
 305 "        YES )\n"
 306 "            if [ -n \"${OPT_ARG}\" ]\n"
 307 "            then\n"
 308 "                OPT_ARG_VAL=\"${OPT_ARG}\"\n\n"
 309 "            else\n"
 310 "                if [ $# -eq 0 ]\n"
 311 "                then\n"
 312 "                    echo No argument provided for ${OPT_NAME} option >&2\n"
 313 "                    echo \"$%s_USAGE_TEXT\"\n"
 314 "                    exit 1\n"
 315 "                fi\n"
 316 "                shift\n"
 317 "                OPT_ARG_VAL=\"$1\"\n"
 318 "            fi\n\n"
 319 "            shift\n"
 320 "            OPT_ARG=\"$1\"\n"
 321 "            ;;\n\n"
 322 "        OK )\n"
 323 "            if [ -n \"${OPT_ARG}\" ]\n"
 324 "            then\n"
 325 "                OPT_ARG_VAL=\"${OPT_ARG}\"\n"
 326 "                shift\n"
 327 "                OPT_ARG=\"$1\"\n\n"
 328 "            else\n"
 329 "                shift\n"
 330 "                if [ $# -gt 0 ]\n"
 331 "                then\n"
 332 "                    case \"$1\" in -* ) ;; * )\n"
 333 "                        OPT_ARG_VAL=\"$1\"\n"
 334 "                        shift ;; esac\n"
 335 "                    OPT_ARG=\"$1\"\n"
 336 "                fi\n"
 337 "            fi\n"
 338 "            ;;\n"
 339 "        esac\n";
 340
 341 tSCC* pzShell = NULL;
 342 static char*  pzLeader  = NULL;
 343 static char*  pzTrailer = NULL;
 344
 345 /* = = = START-STATIC-FORWARD = = = */
 346 /* static forward declarations maintained by mk-fwd */
 347 static void
 348 textToVariable( tOptions* pOpts, teTextTo whichVar, tOptDesc* pOD );
 349
 350 static void
 351 emitUsage( tOptions* pOpts );
 352
 353 static void
 354 emitSetup( tOptions* pOpts );
 355
 356 static void
 357 printOptionAction( tOptions* pOpts, tOptDesc* pOptDesc );
 358
 359 static void
 360 printOptionInaction( tOptions* pOpts, tOptDesc* pOptDesc );
 361
 362 static void
 363 emitFlag( tOptions* pOpts );
 364
 365 static void
 366 emitMatchExpr( tCC* pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts );
 367
 368 static void
 369 emitLong( tOptions* pOpts );
 370
 371 static void
 372 openOutput( char const* pzFile );
 373 /* = = = END-STATIC-FORWARD = = = */
 374
 375 /*=export_func  optionParseShell
 376  * private:
 377  *
 378  * what:  Decipher a boolean value
 379  * arg:   + tOptions* + pOpts    + program options descriptor +
 380  *
 381  * doc:
 382  *  Emit a shell script that will parse the command line options.
 383 =*/
 384 void
 385 optionParseShell( tOptions* pOpts )
 386 {
 387     /*
 388      *  Check for our SHELL option now.
 389      *  IF the output file contains the "#!" magic marker,
 390      *  it will override anything we do here.
 391      */
 392     if (HAVE_OPT( SHELL ))
 393         pzShell = OPT_ARG( SHELL );
 394
 395     else if (! ENABLED_OPT( SHELL ))
 396         pzShell = NULL;
 397
 398     else if ((pzShell = getenv( "SHELL" )),
 399              pzShell == NULL)
 400
 401         pzShell = "/bin/sh";
 402
 403     /*
 404      *  Check for a specified output file
 405      */
 406     if (HAVE_OPT( SCRIPT ))
 407         openOutput( OPT_ARG( SCRIPT ));
 408
 409     emitUsage( pOpts );
 410     emitSetup( pOpts );
 411
 412     /*
 413      *  There are four modes of option processing.
 414      */
 415     switch (pOpts->fOptSet & (OPTPROC_LONGOPT|OPTPROC_SHORTOPT)) {
 416     case OPTPROC_LONGOPT:
 417         fputs( zLoopCase,        stdout );
 418
 419         fputs( zLongSelection,   stdout );
 420         fputs( zLongOptInit,     stdout );
 421         emitLong( pOpts );
 422         printf( zLongOptArg,     pOpts->pzPROGNAME );
 423         fputs( zEndSelection,    stdout );
 424
 425         fputs( zNoSelection,     stdout );
 426         break;
 427
 428     case 0:
 429         fputs( zLoopOnly,        stdout );
 430         fputs( zLongOptInit,     stdout );
 431         emitLong( pOpts );
 432         printf( zLongOptArg,     pOpts->pzPROGNAME );
 433         break;
 434
 435     case OPTPROC_SHORTOPT:
 436         fputs( zLoopCase,        stdout );
 437
 438         fputs( zFlagSelection,   stdout );
 439         fputs( zFlagOptInit,     stdout );
 440         emitFlag( pOpts );
 441         printf( zFlagOptArg,     pOpts->pzPROGNAME );
 442         fputs( zEndSelection,    stdout );
 443
 444         fputs( zNoSelection,     stdout );
 445         break;
 446
 447     case OPTPROC_LONGOPT|OPTPROC_SHORTOPT:
 448         fputs( zLoopCase,        stdout );
 449
 450         fputs( zLongSelection,   stdout );
 451         fputs( zLongOptInit,     stdout );
 452         emitLong( pOpts );
 453         printf( zLongOptArg,     pOpts->pzPROGNAME );
 454         fputs( zEndSelection,    stdout );
 455
 456         fputs( zFlagSelection,   stdout );
 457         fputs( zFlagOptInit,     stdout );
 458         emitFlag( pOpts );
 459         printf( zFlagOptArg,     pOpts->pzPROGNAME );
 460         fputs( zEndSelection,    stdout );
 461
 462         fputs( zNoSelection,     stdout );
 463         break;
 464     }
 465
 466     printf( zLoopEnd, pOpts->pzPROGNAME, zTrailerMarker );
 467     if ((pzTrailer != NULL) && (*pzTrailer != '\0'))
 468         fputs( pzTrailer, stdout );
 469     else if (ENABLED_OPT( SHELL ))
 470         printf( "\nenv | grep '^%s_'\n", pOpts->pzPROGNAME );
 471
 472     fflush( stdout );
 473     fchmod( STDOUT_FILENO, 0755 );
 474     fclose( stdout );
 475 }
 476
 477
 478 static void
 479 textToVariable( tOptions* pOpts, teTextTo whichVar, tOptDesc* pOD )
 480 {
 481 #   define _TT_(n) tSCC z ## n [] = #n;
 482     TEXTTO_TABLE
 483 #   undef _TT_
 484 #   define _TT_(n) z ## n ,
 485       static char const*  apzTTNames[] = { TEXTTO_TABLE };
 486 #   undef _TT_
 487
 488 #if ! defined(HAVE_WORKING_FORK)
 489     printf( "%1$s_%2$s_TEXT='no %2$s text'\n",
 490             pOpts->pzPROGNAME, apzTTNames[ whichVar ]);
 491 #else
 492     int  nlHoldCt = 0;
 493     int  pipeFd[2];
 494     FILE* fp;
 495
 496     printf( "%s_%s_TEXT='", pOpts->pzPROGNAME, apzTTNames[ whichVar ]);
 497     fflush( stdout );
 498
 499     if (pipe( pipeFd ) != 0) {
 500         fprintf( stderr, zBadPipe, errno, strerror( errno ));
 501         exit( EXIT_FAILURE );
 502     }
 503
 504     switch (fork()) {
 505     case -1:
 506         fprintf( stderr, zForkFail, errno, strerror(errno), pOpts->pzProgName);
 507         exit( EXIT_FAILURE );
 508         break;
 509
 510     case 0:
 511         dup2( pipeFd[1], STDERR_FILENO );
 512         dup2( pipeFd[1], STDOUT_FILENO );
 513         close( pipeFd[0] );
 514
 515         switch (whichVar) {
 516         case TT_LONGUSAGE:
 517             (*(pOpts->pUsageProc))( pOpts, EXIT_SUCCESS );
 518             /* NOTREACHED */
 519             exit( EXIT_FAILURE );
 520
 521         case TT_USAGE:
 522             (*(pOpts->pUsageProc))( pOpts, EXIT_FAILURE );
 523             /* NOTREACHED */
 524             exit( EXIT_FAILURE );
 525
 526         case TT_VERSION:
 527             if (pOD->fOptState & OPTST_ALLOC_ARG) {
 528                 AGFREE(pOD->optArg.argString);
 529                 pOD->fOptState &= ~OPTST_ALLOC_ARG;
 530             }
 531             pOD->optArg.argString = "c";
 532             optionPrintVersion( pOpts, pOD );
 533             /* NOTREACHED */
 534
 535         default:
 536             exit( EXIT_FAILURE );
 537         }
 538
 539     default:
 540         close( pipeFd[1] );
 541         fp = fdopen( pipeFd[0], "r" FOPEN_BINARY_FLAG );
 542     }
 543
 544     for (;;) {
 545         int  ch = fgetc( fp );
 546         switch (ch) {
 547
 548         case '\n':
 549             nlHoldCt++;
 550             break;
 551
 552         case '\'':
 553             while (nlHoldCt > 0) {
 554                 fputc( '\n', stdout );
 555                 nlHoldCt--;
 556             }
 557             fputs( "'\\''", stdout );
 558             break;
 559
 560         case EOF:
 561             goto endCharLoop;
 562
 563         default:
 564             while (nlHoldCt > 0) {
 565                 fputc( '\n', stdout );
 566                 nlHoldCt--;
 567             }
 568             fputc( ch, stdout );
 569             break;
 570         }
 571     } endCharLoop:;
 572
 573     fputs( "'\n\n", stdout );
 574     close( pipeFd[0] );
 575 #endif
 576 }
 577
 578
 579 static void
 580 emitUsage( tOptions* pOpts )
 581 {
 582     char     zTimeBuf[ AO_NAME_SIZE ];
 583
 584     /*
 585      *  First, switch stdout to the output file name.
 586      *  Then, change the program name to the one defined
 587      *  by the definitions (rather than the current
 588      *  executable name).  Down case the upper cased name.
 589      */
 590     if (pzLeader != NULL)
 591         fputs( pzLeader, stdout );
 592
 593     {
 594         tSCC    zStdout[] = "stdout";
 595         tCC*    pzOutName;
 596
 597         {
 598             time_t    curTime = time( NULL );
 599             struct tm*  pTime = localtime( &curTime );
 600             strftime(zTimeBuf, AO_NAME_SIZE, "%A %B %e, %Y at %r %Z", pTime );
 601         }
 602
 603         if (HAVE_OPT( SCRIPT ))
 604              pzOutName = OPT_ARG( SCRIPT );
 605         else pzOutName = zStdout;
 606
 607         if ((pzLeader == NULL) && (pzShell != NULL))
 608             printf( "#! %s\n", pzShell );
 609
 610         printf( zPreamble, zStartMarker, pzOutName, zTimeBuf );
 611     }
 612
 613     /*
 614      *  Get a copy of the original program name in lower case
 615      */
 616     {
 617         char* pzPN = zTimeBuf;
 618         tCC*  pz   = pOpts->pzPROGNAME;
 619         for (;;) {
 620             if ((*pzPN++ = tolower( *pz++ )) == '\0')
 621                 break;
 622         }
 623     }
 624
 625     printf( zEndPreamble, pOpts->pzPROGNAME );
 626
 627     pOpts->pzProgPath = pOpts->pzProgName = zTimeBuf;
 628     textToVariable( pOpts, TT_LONGUSAGE, NULL );
 629     textToVariable( pOpts, TT_USAGE,     NULL );
 630
 631     {
 632         tOptDesc* pOptDesc = pOpts->pOptDesc;
 633         int       optionCt = pOpts->optCt;
 634
 635         for (;;) {
 636             if (pOptDesc->pOptProc == optionPrintVersion) {
 637                 textToVariable( pOpts, TT_VERSION, pOptDesc );
 638                 break;
 639             }
 640
 641             if (--optionCt <= 0)
 642                 break;
 643             pOptDesc++;
 644         }
 645     }
 646 }
 647
 648
 649 static void
 650 emitSetup( tOptions* pOpts )
 651 {
 652     tOptDesc* pOptDesc = pOpts->pOptDesc;
 653     int       optionCt = pOpts->presetOptCt;
 654     char const* pzFmt;
 655     char const* pzDefault;
 656
 657     for (;optionCt > 0; pOptDesc++, --optionCt) {
 658         char zVal[16];
 659
 660         /*
 661          *  Options that are either usage documentation or are compiled out
 662          *  are not to be processed.
 663          */
 664         if (SKIP_OPT(pOptDesc) || (pOptDesc->pz_NAME == NULL))
 665             continue;
 666
 667         if (pOptDesc->optMaxCt > 1)
 668              pzFmt = zMultiDef;
 669         else pzFmt = zSingleDef;
 670
 671         /*
 672          *  IF this is an enumeration/bitmask option, then convert the value
 673          *  to a string before printing the default value.
 674          */
 675         switch (OPTST_GET_ARGTYPE(pOptDesc->fOptState)) {
 676         case OPARG_TYPE_ENUMERATION:
 677             (*(pOptDesc->pOptProc))(OPTPROC_EMIT_SHELL, pOptDesc );
 678             pzDefault = pOptDesc->optArg.argString;
 679             break;
 680
 681         /*
 682          *  Numeric and membership bit options are just printed as a number.
 683          */
 684         case OPARG_TYPE_NUMERIC:
 685             snprintf( zVal, sizeof( zVal ), "%d",
 686                       (int)pOptDesc->optArg.argInt );
 687             pzDefault = zVal;
 688             break;
 689
 690         case OPARG_TYPE_MEMBERSHIP:
 691             snprintf( zVal, sizeof( zVal ), "%lu",
 692                       (unsigned long)pOptDesc->optArg.argIntptr );
 693             pzDefault = zVal;
 694             break;
 695
 696         case OPARG_TYPE_BOOLEAN:
 697             pzDefault = (pOptDesc->optArg.argBool) ? "true" : "false";
 698             break;
 699
 700         default:
 701             if (pOptDesc->optArg.argString == NULL) {
 702                 if (pzFmt == zSingleDef)
 703                     pzFmt = zSingleNoDef;
 704                 pzDefault = NULL;
 705             }
 706             else
 707                 pzDefault = pOptDesc->optArg.argString;
 708         }
 709
 710         printf( pzFmt, pOpts->pzPROGNAME, pOptDesc->pz_NAME, pzDefault );
 711     }
 712 }
 713
 714
 715 static void
 716 printOptionAction( tOptions* pOpts, tOptDesc* pOptDesc )
 717 {
 718     if (pOptDesc->pOptProc == optionPrintVersion)
 719         printf( zTextExit, pOpts->pzPROGNAME, "VERSION" );
 720
 721     else if (pOptDesc->pOptProc == optionPagedUsage)
 722         printf( zPagedUsageExit, pOpts->pzPROGNAME );
 723
 724     else if (pOptDesc->pOptProc == optionLoadOpt) {
 725         printf( zCmdFmt, "echo 'Warning:  Cannot load options files' >&2" );
 726         printf( zCmdFmt, "OPT_ARG_NEEDED=YES" );
 727
 728     } else if (pOptDesc->pz_NAME == NULL) {
 729
 730         if (pOptDesc->pOptProc == NULL) {
 731             printf( zCmdFmt, "echo 'Warning:  Cannot save options files' "
 732                     ">&2" );
 733             printf( zCmdFmt, "OPT_ARG_NEEDED=OK" );
 734         } else
 735             printf( zTextExit, pOpts->pzPROGNAME, "LONGUSAGE" );
 736
 737     } else {
 738         if (pOptDesc->optMaxCt == 1)
 739             printf( zSingleArg, pOpts->pzPROGNAME, pOptDesc->pz_NAME );
 740         else {
 741             if ((unsigned)pOptDesc->optMaxCt < NOLIMIT)
 742                 printf( zCountTest, pOpts->pzPROGNAME,
 743                         pOptDesc->pz_NAME, pOptDesc->optMaxCt );
 744
 745             printf( zMultiArg, pOpts->pzPROGNAME, pOptDesc->pz_NAME );
 746         }
 747
 748         /*
 749          *  Fix up the args.
 750          */
 751         if (OPTST_GET_ARGTYPE(pOptDesc->fOptState) == OPARG_TYPE_NONE) {
 752             printf( zCantArg, pOpts->pzPROGNAME, pOptDesc->pz_NAME );
 753
 754         } else if (pOptDesc->fOptState & OPTST_ARG_OPTIONAL) {
 755             printf( zMayArg,  pOpts->pzPROGNAME, pOptDesc->pz_NAME );
 756
 757         } else {
 758             fputs( zMustArg, stdout );
 759         }
 760     }
 761     fputs( zOptionEndSelect, stdout );
 762 }
 763
 764
 765 static void
 766 printOptionInaction( tOptions* pOpts, tOptDesc* pOptDesc )
 767 {
 768     if (pOptDesc->pOptProc == optionLoadOpt) {
 769         printf( zCmdFmt, "echo 'Warning:  Cannot suppress the loading of "
 770                 "options files' >&2" );
 771
 772     } else if (pOptDesc->optMaxCt == 1)
 773         printf( zNoSingleArg, pOpts->pzPROGNAME,
 774                 pOptDesc->pz_NAME, pOptDesc->pz_DisablePfx );
 775     else
 776         printf( zNoMultiArg, pOpts->pzPROGNAME,
 777                 pOptDesc->pz_NAME, pOptDesc->pz_DisablePfx );
 778
 779     printf( zCmdFmt, "OPT_ARG_NEEDED=NO" );
 780     fputs( zOptionEndSelect, stdout );
 781 }
 782
 783
 784 static void
 785 emitFlag( tOptions* pOpts )
 786 {
 787     tOptDesc* pOptDesc = pOpts->pOptDesc;
 788     int       optionCt = pOpts->optCt;
 789
 790     fputs( zOptionCase, stdout );
 791
 792     for (;optionCt > 0; pOptDesc++, --optionCt) {
 793
 794         if (SKIP_OPT(pOptDesc))
 795             continue;
 796
 797         if (IS_GRAPHIC_CHAR(pOptDesc->optValue)) {
 798             printf( zOptionFlag, pOptDesc->optValue );
 799             printOptionAction( pOpts, pOptDesc );
 800         }
 801     }
 802     printf( zOptionUnknown, "flag", pOpts->pzPROGNAME );
 803 }
 804
 805
 806 /*
 807  *  Emit the match text for a long option
 808  */
 809 static void
 810 emitMatchExpr( tCC* pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts )
 811 {
 812     tOptDesc* pOD = pOpts->pOptDesc;
 813     int       oCt = pOpts->optCt;
 814     int       min = 1;
 815     char      zName[ 256 ];
 816     char*     pz  = zName;
 817
 818     for (;;) {
 819         int matchCt = 0;
 820
 821         /*
 822          *  Omit the current option, Documentation opts and compiled out opts.
 823          */
 824         if ((pOD == pCurOpt) || SKIP_OPT(pOD)){
 825             if (--oCt <= 0)
 826                 break;
 827             pOD++;
 828             continue;
 829         }
 830
 831         /*
 832          *  Check each character of the name case insensitively.
 833          *  They must not be the same.  They cannot be, because it would
 834          *  not compile correctly if they were.
 835          */
 836         while (  toupper( pOD->pz_Name[matchCt] )
 837               == toupper( pzMatchName[matchCt] ))
 838             matchCt++;
 839
 840         if (matchCt > min)
 841             min = matchCt;
 842
 843         /*
 844          *  Check the disablement name, too.
 845          */
 846         if (pOD->pz_DisableName != NULL) {
 847             matchCt = 0;
 848             while (  toupper( pOD->pz_DisableName[matchCt] )
 849                   == toupper( pzMatchName[matchCt] ))
 850                 matchCt++;
 851             if (matchCt > min)
 852                 min = matchCt;
 853         }
 854         if (--oCt <= 0)
 855             break;
 856         pOD++;
 857     }
 858
 859     /*
 860      *  IF the 'min' is all or one short of the name length,
 861      *  THEN the entire string must be matched.
 862      */
 863     if (  (pzMatchName[min  ] == NUL)
 864        || (pzMatchName[min+1] == NUL) )
 865         printf( zOptionFullName, pzMatchName );
 866
 867     else {
 868         int matchCt = 0;
 869         for (; matchCt <= min; matchCt++)
 870             *pz++ = pzMatchName[matchCt];
 871
 872         for (;;) {
 873             *pz = NUL;
 874             printf( zOptionPartName, zName );
 875             *pz++ = pzMatchName[matchCt++];
 876             if (pzMatchName[matchCt] == NUL) {
 877                 *pz = NUL;
 878                 printf( zOptionFullName, zName );
 879                 break;
 880             }
 881         }
 882     }
 883 }
 884
 885
 886 /*
 887  *  Emit GNU-standard long option handling code
 888  */
 889 static void
 890 emitLong( tOptions* pOpts )
 891 {
 892     tOptDesc* pOD = pOpts->pOptDesc;
 893     int       ct  = pOpts->optCt;
 894
 895     fputs( zOptionCase, stdout );
 896
 897     /*
 898      *  do each option, ...
 899      */
 900     do  {
 901         /*
 902          *  Documentation & compiled-out options
 903          */
 904         if (SKIP_OPT(pOD))
 905             continue;
 906
 907         emitMatchExpr( pOD->pz_Name, pOD, pOpts );
 908         printOptionAction( pOpts, pOD );
 909
 910         /*
 911          *  Now, do the same thing for the disablement version of the option.
 912          */
 913         if (pOD->pz_DisableName != NULL) {
 914             emitMatchExpr( pOD->pz_DisableName, pOD, pOpts );
 915             printOptionInaction( pOpts, pOD );
 916         }
 917     } while (pOD++, --ct > 0);
 918
 919     printf( zOptionUnknown, "option", pOpts->pzPROGNAME );
 920 }
 921
 922
 923 static void
 924 openOutput( char const* pzFile )
 925 {
 926     FILE* fp;
 927     char* pzData = NULL;
 928     struct stat stbf;
 929
 930     do  {
 931         char*    pzScan;
 932         size_t sizeLeft;
 933
 934         /*
 935          *  IF we cannot stat the file,
 936          *  THEN assume we are creating a new file.
 937          *       Skip the loading of the old data.
 938          */
 939         if (stat( pzFile, &stbf ) != 0)
 940             break;
 941
 942         /*
 943          *  The file must be a regular file
 944          */
 945         if (! S_ISREG( stbf.st_mode )) {
 946             fprintf( stderr, zNotFile, pzFile );
 947             exit( EXIT_FAILURE );
 948         }
 949
 950         pzData = AGALOC(stbf.st_size + 1, "file data");
 951         fp = fopen( pzFile, "r" FOPEN_BINARY_FLAG );
 952
 953         sizeLeft = (unsigned)stbf.st_size;
 954         pzScan   = pzData;
 955
 956         /*
 957          *  Read in all the data as fast as our OS will let us.
 958          */
 959         for (;;) {
 960             int inct = fread( (void*)pzScan, (size_t)1, sizeLeft, fp);
 961             if (inct == 0)
 962                 break;
 963
 964             pzScan   += inct;
 965             sizeLeft -= inct;
 966
 967             if (sizeLeft == 0)
 968                 break;
 969         }
 970
 971         /*
 972          *  NUL-terminate the leader and look for the trailer
 973          */
 974         *pzScan = '\0';
 975         fclose( fp );
 976         pzScan  = strstr( pzData, zStartMarker );
 977         if (pzScan == NULL) {
 978             pzTrailer = pzData;
 979             break;
 980         }
 981
 982         *(pzScan++) = NUL;
 983         pzScan  = strstr( pzScan, zTrailerMarker );
 984         if (pzScan == NULL) {
 985             pzTrailer = pzData;
 986             break;
 987         }
 988
 989         /*
 990          *  Check to see if the data contains
 991          *  our marker.  If it does, then we will skip over it
 992          */
 993         pzTrailer = pzScan + sizeof( zTrailerMarker ) - 1;
 994         pzLeader  = pzData;
 995     } while (AG_FALSE);
 996
 997     freopen( pzFile, "w" FOPEN_BINARY_FLAG, stdout );
 998 }
 999
1000
1001 /*=export_func genshelloptUsage
1002  * private:
1003  * what: The usage function for the genshellopt generated program
1004  *
1005  * arg:  + tOptions* + pOpts    + program options descriptor +
1006  * arg:  + int       + exitCode + usage text type to produce +
1007  *
1008  * doc:
1009  *  This function is used to create the usage strings for the option
1010  *  processing shell script code.  Two child processes are spawned
1011  *  each emitting the usage text in either the short (error exit)
1012  *  style or the long style.  The generated program will capture this
1013  *  and create shell script variables containing the two types of text.
1014 =*/
1015 void
1016 genshelloptUsage( tOptions*  pOpts, int exitCode )
1017 {
1018 #if ! defined(HAVE_WORKING_FORK)
1019     optionUsage( pOpts, exitCode );
1020 #else
1021     /*
1022      *  IF not EXIT_SUCCESS,
1023      *  THEN emit the short form of usage.
1024      */
1025     if (exitCode != EXIT_SUCCESS)
1026         optionUsage( pOpts, exitCode );
1027     fflush( stderr );
1028     fflush( stdout );
1029
1030     option_usage_fp = stdout;
1031
1032     /*
1033      *  First, print our usage
1034      */
1035     switch (fork()) {
1036     case -1:
1037         optionUsage( pOpts, EXIT_FAILURE );
1038         /* NOTREACHED */
1039         _exit( EXIT_FAILURE );
1040
1041     case 0:
1042         pagerState = PAGER_STATE_CHILD;
1043         optionUsage( pOpts, EXIT_SUCCESS );
1044         /* NOTREACHED */
1045         _exit( EXIT_FAILURE );
1046
1047     default:
1048     {
1049         int  sts;
1050         wait( &sts );
1051     }
1052     }
1053
1054     /*
1055      *  Generate the pzProgName, since optionProcess() normally
1056      *  gets it from the command line
1057      */
1058     {
1059         char* pz;
1060         AGDUPSTR( pz, pShellParseOptions->pzPROGNAME, "program name" );
1061         pShellParseOptions->pzProgName = pz;
1062         while (*pz != NUL) {
1063             *pz = tolower( *pz );
1064             pz++;
1065         }
1066     }
1067
1068     /*
1069      *  Separate the makeshell usage from the client usage
1070      */
1071     fprintf( option_usage_fp, zGenshell, pShellParseOptions->pzProgName );
1072     fflush( option_usage_fp );
1073
1074     /*
1075      *  Now, print the client usage.
1076      */
1077     switch (fork()) {
1078     case 0:
1079         pagerState = PAGER_STATE_CHILD;
1080         /*FALLTHROUGH*/
1081     case -1:
1082         optionUsage( pShellParseOptions, EXIT_FAILURE );
1083
1084     default:
1085     {
1086         int  sts;
1087         wait( &sts );
1088     }
1089     }
1090
1091     exit( EXIT_SUCCESS );
1092 #endif
1093 }
1094
1095 /*
1096  * Local Variables:
1097  * mode: C
1098  * c-file-style: "stroustrup"
1099  * indent-tabs-mode: nil
1100  * End:
1101  * end of autoopts/makeshell.c */