src/libopts/makeshell.c

   1
   2 /**
   3  * \file makeshell.c
   4  *
   5  * Time-stamp:      "2012-04-07 09:03:16 bkorb"
   6  *
   7  *  This module will interpret the options set in the tOptions
   8  *  structure and create a Bourne shell script capable of parsing them.
   9  *
  10  *  This file is part of AutoOpts, a companion to AutoGen.
  11  *  AutoOpts is free software.
  12  *  AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved
  13  *
  14  *  AutoOpts is available under any one of two licenses.  The license
  15  *  in use must be one of these two and the choice is under the control
  16  *  of the user of the license.
  17  *
  18  *   The GNU Lesser General Public License, version 3 or later
  19  *      See the files "COPYING.lgplv3" and "COPYING.gplv3"
  20  *
  21  *   The Modified Berkeley Software Distribution License
  22  *      See the file "COPYING.mbsd"
  23  *
  24  *  These files have the following md5sums:
  25  *
  26  *  43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
  27  *  06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
  28  *  66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
  29  */
  30
  31 #include <config.h>
  32
  33 /* Work around problem reported in
  34    <http://permalink.gmane.org/gmane.comp.lib.gnulib.bugs/15755>.*/
  35 #if GETTIMEOFDAY_CLOBBERS_LOCALTIME
  36 #undef localtime
  37 #endif
  38
  39 tOptions * optionParseShellOptions = NULL;
  40
  41 static char const * shell_prog = NULL;
  42 static char * script_leader    = NULL;
  43 static char * script_trailer   = NULL;
  44
  45 /* = = = START-STATIC-FORWARD = = = */
  46 static void
  47 emit_var_text(char const * prog, char const * var, int fdin);
  48
  49 static void
  50 text_to_var(tOptions * pOpts, teTextTo whichVar, tOptDesc * pOD);
  51
  52 static void
  53 emit_usage(tOptions * pOpts);
  54
  55 static void
  56 emit_setup(tOptions * pOpts);
  57
  58 static void
  59 emit_action(tOptions * pOpts, tOptDesc* pOptDesc);
  60
  61 static void
  62 emit_inaction(tOptions * pOpts, tOptDesc* pOptDesc);
  63
  64 static void
  65 emit_flag(tOptions * pOpts);
  66
  67 static void
  68 emit_match_expr(char const * pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts);
  69
  70 static void
  71 emitLong(tOptions * pOpts);
  72
  73 static void
  74 open_out(char const * pzFile);
  75 /* = = = END-STATIC-FORWARD = = = */
  76
  77 /*=export_func  optionParseShell
  78  * private:
  79  *
  80  * what:  Decipher a boolean value
  81  * arg:   + tOptions* + pOpts    + program options descriptor +
  82  *
  83  * doc:
  84  *  Emit a shell script that will parse the command line options.
  85 =*/
  86 void
  87 optionParseShell(tOptions * pOpts)
  88 {
  89     /*
  90      *  Check for our SHELL option now.
  91      *  IF the output file contains the "#!" magic marker,
  92      *  it will override anything we do here.
  93      */
  94     if (HAVE_GENSHELL_OPT(SHELL))
  95         shell_prog = GENSHELL_OPT_ARG(SHELL);
  96
  97     else if (! ENABLED_GENSHELL_OPT(SHELL))
  98         shell_prog = NULL;
  99
 100     else if ((shell_prog = getenv("SHELL")),
 101              shell_prog == NULL)
 102
 103         shell_prog = POSIX_SHELL;
 104
 105     /*
 106      *  Check for a specified output file
 107      */
 108     if (HAVE_GENSHELL_OPT(SCRIPT))
 109         open_out(GENSHELL_OPT_ARG(SCRIPT));
 110
 111     emit_usage(pOpts);
 112     emit_setup(pOpts);
 113
 114     /*
 115      *  There are four modes of option processing.
 116      */
 117     switch (pOpts->fOptSet & (OPTPROC_LONGOPT|OPTPROC_SHORTOPT)) {
 118     case OPTPROC_LONGOPT:
 119         fputs(LOOP_STR,         stdout);
 120
 121         fputs(LONG_OPT_MARK,    stdout);
 122         fputs(INIT_LOPT_STR,    stdout);
 123         emitLong(pOpts);
 124         printf(LOPT_ARG_FMT,    pOpts->pzPROGNAME);
 125         fputs(END_OPT_SEL_STR,  stdout);
 126
 127         fputs(NOT_FOUND_STR,    stdout);
 128         break;
 129
 130     case 0:
 131         fputs(ONLY_OPTS_LOOP,   stdout);
 132         fputs(INIT_LOPT_STR,    stdout);
 133         emitLong(pOpts);
 134         printf(LOPT_ARG_FMT,    pOpts->pzPROGNAME);
 135         break;
 136
 137     case OPTPROC_SHORTOPT:
 138         fputs(LOOP_STR,         stdout);
 139
 140         fputs(FLAG_OPT_MARK,    stdout);
 141         fputs(INIT_OPT_STR,     stdout);
 142         emit_flag(pOpts);
 143         printf(OPT_ARG_FMT,     pOpts->pzPROGNAME);
 144         fputs(END_OPT_SEL_STR,  stdout);
 145
 146         fputs(NOT_FOUND_STR,    stdout);
 147         break;
 148
 149     case OPTPROC_LONGOPT|OPTPROC_SHORTOPT:
 150         fputs(LOOP_STR,         stdout);
 151
 152         fputs(LONG_OPT_MARK,    stdout);
 153         fputs(INIT_LOPT_STR,    stdout);
 154         emitLong(pOpts);
 155         printf(LOPT_ARG_FMT,    pOpts->pzPROGNAME);
 156         fputs(END_OPT_SEL_STR,  stdout);
 157
 158         fputs(FLAG_OPT_MARK,    stdout);
 159         fputs(INIT_OPT_STR,     stdout);
 160         emit_flag(pOpts);
 161         printf(OPT_ARG_FMT,     pOpts->pzPROGNAME);
 162         fputs(END_OPT_SEL_STR,  stdout);
 163
 164         fputs(NOT_FOUND_STR,    stdout);
 165         break;
 166     }
 167
 168     printf(zLoopEnd, pOpts->pzPROGNAME, END_MARK);
 169     if ((script_trailer != NULL) && (*script_trailer != NUL))
 170         fputs(script_trailer, stdout);
 171     else if (ENABLED_GENSHELL_OPT(SHELL))
 172         printf(SHOW_PROG_ENV, pOpts->pzPROGNAME);
 173
 174 #ifdef HAVE_FCHMOD
 175     fchmod(STDOUT_FILENO, 0755);
 176 #endif
 177     fclose(stdout);
 178
 179     if (ferror(stdout)) {
 180         fputs(zOutputFail, stderr);
 181         exit(EXIT_FAILURE);
 182     }
 183 }
 184
 185 #ifdef HAVE_WORKING_FORK
 186 static void
 187 emit_var_text(char const * prog, char const * var, int fdin)
 188 {
 189     FILE * fp   = fdopen(fdin, "r" FOPEN_BINARY_FLAG);
 190     int    nlct = 0; /* defer newlines and skip trailing ones */
 191
 192     printf(SET_TEXT_FMT, prog, var);
 193     if (fp == NULL)
 194         goto skip_text;
 195
 196     for (;;) {
 197         int  ch = fgetc(fp);
 198         switch (ch) {
 199
 200         case NL:
 201             nlct++;
 202             break;
 203
 204         case '\'':
 205             while (nlct > 0) {
 206                 fputc(NL, stdout);
 207                 nlct--;
 208             }
 209             fputs(apostrophy, stdout);
 210             break;
 211
 212         case EOF:
 213             goto endCharLoop;
 214
 215         default:
 216             while (nlct > 0) {
 217                 fputc(NL, stdout);
 218                 nlct--;
 219             }
 220             fputc(ch, stdout);
 221             break;
 222         }
 223     } endCharLoop:;
 224
 225     fclose(fp);
 226
 227 skip_text:
 228
 229     fputs(END_SET_TEXT, stdout);
 230 }
 231
 232 #endif
 233
 234 /*
 235  *  The purpose of this function is to assign "long usage", short usage
 236  *  and version information to a shell variable.  Rather than wind our
 237  *  way through all the logic necessary to emit the text directly, we
 238  *  fork(), have our child process emit the text the normal way and
 239  *  capture the output in the parent process.
 240  */
 241 static void
 242 text_to_var(tOptions * pOpts, teTextTo whichVar, tOptDesc * pOD)
 243 {
 244 #   define _TT_(n) static char const z ## n [] = #n;
 245     TEXTTO_TABLE
 246 #   undef _TT_
 247 #   define _TT_(n) z ## n ,
 248       static char const * apzTTNames[] = { TEXTTO_TABLE };
 249 #   undef _TT_
 250
 251 #if ! defined(HAVE_WORKING_FORK)
 252     printf(SET_NO_TEXT_FMT, pOpts->pzPROGNAME, apzTTNames[ whichVar]);
 253 #else
 254     int  pipeFd[2];
 255
 256     fflush(stdout);
 257     fflush(stderr);
 258
 259     if (pipe(pipeFd) != 0) {
 260         fprintf(stderr, zBadPipe, errno, strerror(errno));
 261         exit(EXIT_FAILURE);
 262     }
 263
 264     switch (fork()) {
 265     case -1:
 266         fprintf(stderr, zForkFail, errno, strerror(errno), pOpts->pzProgName);
 267         exit(EXIT_FAILURE);
 268         break;
 269
 270     case 0:
 271         /*
 272          * Send both stderr and stdout to the pipe.  No matter which
 273          * descriptor is used, we capture the output on the read end.
 274          */
 275         dup2(pipeFd[1], STDERR_FILENO);
 276         dup2(pipeFd[1], STDOUT_FILENO);
 277         close(pipeFd[0]);
 278
 279         switch (whichVar) {
 280         case TT_LONGUSAGE:
 281             (*(pOpts->pUsageProc))(pOpts, EXIT_SUCCESS);
 282             /* NOTREACHED */
 283
 284         case TT_USAGE:
 285             (*(pOpts->pUsageProc))(pOpts, EXIT_FAILURE);
 286             /* NOTREACHED */
 287
 288         case TT_VERSION:
 289             if (pOD->fOptState & OPTST_ALLOC_ARG) {
 290                 AGFREE(pOD->optArg.argString);
 291                 pOD->fOptState &= ~OPTST_ALLOC_ARG;
 292             }
 293             pOD->optArg.argString = "c";
 294             optionPrintVersion(pOpts, pOD);
 295             /* NOTREACHED */
 296
 297         default:
 298             exit(EXIT_FAILURE);
 299         }
 300
 301     default:
 302         close(pipeFd[1]);
 303     }
 304
 305     emit_var_text(pOpts->pzPROGNAME, apzTTNames[whichVar], pipeFd[0]);
 306 #endif
 307 }
 308
 309
 310 static void
 311 emit_usage(tOptions * pOpts)
 312 {
 313     char zTimeBuf[AO_NAME_SIZE];
 314
 315     /*
 316      *  First, switch stdout to the output file name.
 317      *  Then, change the program name to the one defined
 318      *  by the definitions (rather than the current
 319      *  executable name).  Down case the upper cased name.
 320      */
 321     if (script_leader != NULL)
 322         fputs(script_leader, stdout);
 323
 324     {
 325         char const * out_nm;
 326
 327         {
 328             time_t    c_tim = time(NULL);
 329             struct tm * ptm = localtime(&c_tim);
 330             strftime(zTimeBuf, AO_NAME_SIZE, TIME_FMT, ptm );
 331         }
 332
 333         if (HAVE_GENSHELL_OPT(SCRIPT))
 334              out_nm = GENSHELL_OPT_ARG(SCRIPT);
 335         else out_nm = STDOUT;
 336
 337         if ((script_leader == NULL) && (shell_prog != NULL))
 338             printf(SHELL_MAGIC, shell_prog);
 339
 340         printf(PREAMBLE_FMT, START_MARK, out_nm, zTimeBuf);
 341     }
 342
 343     printf(END_PRE_FMT, pOpts->pzPROGNAME);
 344
 345     /*
 346      *  Get a copy of the original program name in lower case and
 347      *  fill in an approximation of the program name from it.
 348      */
 349     {
 350         char *       pzPN = zTimeBuf;
 351         char const * pz   = pOpts->pzPROGNAME;
 352         char **      pp;
 353
 354         for (;;) {
 355             if ((*pzPN++ = (char)tolower(*pz++)) == NUL)
 356                 break;
 357         }
 358
 359         pp = (char **)(void *)&(pOpts->pzProgPath);
 360         *pp = zTimeBuf;
 361         pp  = (char **)(void *)&(pOpts->pzProgName);
 362         *pp = zTimeBuf;
 363     }
 364
 365     text_to_var(pOpts, TT_LONGUSAGE, NULL);
 366     text_to_var(pOpts, TT_USAGE,     NULL);
 367
 368     {
 369         tOptDesc* pOptDesc = pOpts->pOptDesc;
 370         int       optionCt = pOpts->optCt;
 371
 372         for (;;) {
 373             if (pOptDesc->pOptProc == optionPrintVersion) {
 374                 text_to_var(pOpts, TT_VERSION, pOptDesc);
 375                 break;
 376             }
 377
 378             if (--optionCt <= 0)
 379                 break;
 380             pOptDesc++;
 381         }
 382     }
 383 }
 384
 385
 386 static void
 387 emit_setup(tOptions * pOpts)
 388 {
 389     tOptDesc *   pOptDesc = pOpts->pOptDesc;
 390     int          optionCt = pOpts->presetOptCt;
 391     char const * pzFmt;
 392     char const * pzDefault;
 393
 394     for (;optionCt > 0; pOptDesc++, --optionCt) {
 395         char zVal[32];
 396
 397         /*
 398          *  Options that are either usage documentation or are compiled out
 399          *  are not to be processed.
 400          */
 401         if (SKIP_OPT(pOptDesc) || (pOptDesc->pz_NAME == NULL))
 402             continue;
 403
 404         if (pOptDesc->optMaxCt > 1)
 405              pzFmt = MULTI_DEF_FMT;
 406         else pzFmt = SGL_DEF_FMT;
 407
 408         /*
 409          *  IF this is an enumeration/bitmask option, then convert the value
 410          *  to a string before printing the default value.
 411          */
 412         switch (OPTST_GET_ARGTYPE(pOptDesc->fOptState)) {
 413         case OPARG_TYPE_ENUMERATION:
 414             (*(pOptDesc->pOptProc))(OPTPROC_EMIT_SHELL, pOptDesc );
 415             pzDefault = pOptDesc->optArg.argString;
 416             break;
 417
 418         /*
 419          *  Numeric and membership bit options are just printed as a number.
 420          */
 421         case OPARG_TYPE_NUMERIC:
 422             snprintf(zVal, sizeof(zVal), "%d",
 423                      (int)pOptDesc->optArg.argInt);
 424             pzDefault = zVal;
 425             break;
 426
 427         case OPARG_TYPE_MEMBERSHIP:
 428             snprintf(zVal, sizeof(zVal), "%lu",
 429                      (unsigned long)pOptDesc->optArg.argIntptr);
 430             pzDefault = zVal;
 431             break;
 432
 433         case OPARG_TYPE_BOOLEAN:
 434             pzDefault = (pOptDesc->optArg.argBool) ? TRUE_STR : FALSE_STR;
 435             break;
 436
 437         default:
 438             if (pOptDesc->optArg.argString == NULL) {
 439                 if (pzFmt == SGL_DEF_FMT)
 440                     pzFmt = SGL_NO_DEF_FMT;
 441                 pzDefault = NULL;
 442             }
 443             else
 444                 pzDefault = pOptDesc->optArg.argString;
 445         }
 446
 447         printf(pzFmt, pOpts->pzPROGNAME, pOptDesc->pz_NAME, pzDefault);
 448     }
 449 }
 450
 451 static void
 452 emit_action(tOptions * pOpts, tOptDesc* pOptDesc)
 453 {
 454     if (pOptDesc->pOptProc == optionPrintVersion)
 455         printf(zTextExit, pOpts->pzPROGNAME, VER_STR);
 456
 457     else if (pOptDesc->pOptProc == optionPagedUsage)
 458         printf(zPagedUsageExit, pOpts->pzPROGNAME);
 459
 460     else if (pOptDesc->pOptProc == optionLoadOpt) {
 461         printf(zCmdFmt, NO_LOAD_WARN);
 462         printf(zCmdFmt, YES_NEED_OPT_ARG);
 463
 464     } else if (pOptDesc->pz_NAME == NULL) {
 465
 466         if (pOptDesc->pOptProc == NULL) {
 467             printf(zCmdFmt, NO_SAVE_OPTS);
 468             printf(zCmdFmt, OK_NEED_OPT_ARG);
 469         } else
 470             printf(zTextExit, pOpts->pzPROGNAME, LONG_USE_STR);
 471
 472     } else {
 473         if (pOptDesc->optMaxCt == 1)
 474             printf(SGL_ARG_FMT, pOpts->pzPROGNAME, pOptDesc->pz_NAME);
 475         else {
 476             if ((unsigned)pOptDesc->optMaxCt < NOLIMIT)
 477                 printf(zCountTest, pOpts->pzPROGNAME,
 478                        pOptDesc->pz_NAME, pOptDesc->optMaxCt);
 479
 480             printf(MULTI_ARG_FMT, pOpts->pzPROGNAME, pOptDesc->pz_NAME);
 481         }
 482
 483         /*
 484          *  Fix up the args.
 485          */
 486         if (OPTST_GET_ARGTYPE(pOptDesc->fOptState) == OPARG_TYPE_NONE) {
 487             printf(zCantArg, pOpts->pzPROGNAME, pOptDesc->pz_NAME);
 488
 489         } else if (pOptDesc->fOptState & OPTST_ARG_OPTIONAL) {
 490             printf(zMayArg,  pOpts->pzPROGNAME, pOptDesc->pz_NAME);
 491
 492         } else {
 493             fputs(zMustArg, stdout);
 494         }
 495     }
 496     fputs(zOptionEndSelect, stdout);
 497 }
 498
 499
 500 static void
 501 emit_inaction(tOptions * pOpts, tOptDesc* pOptDesc)
 502 {
 503     if (pOptDesc->pOptProc == optionLoadOpt) {
 504         printf(zCmdFmt, NO_SUPPRESS_LOAD);
 505
 506     } else if (pOptDesc->optMaxCt == 1)
 507         printf(NO_SGL_ARG_FMT, pOpts->pzPROGNAME,
 508                pOptDesc->pz_NAME, pOptDesc->pz_DisablePfx);
 509     else
 510         printf(NO_MULTI_ARG_FMT, pOpts->pzPROGNAME,
 511                pOptDesc->pz_NAME, pOptDesc->pz_DisablePfx);
 512
 513     printf(zCmdFmt, NO_ARG_NEEDED);
 514     fputs(zOptionEndSelect, stdout);
 515 }
 516
 517
 518 static void
 519 emit_flag(tOptions * pOpts)
 520 {
 521     tOptDesc* pOptDesc = pOpts->pOptDesc;
 522     int       optionCt = pOpts->optCt;
 523
 524     fputs(zOptionCase, stdout);
 525
 526     for (;optionCt > 0; pOptDesc++, --optionCt) {
 527
 528         if (SKIP_OPT(pOptDesc))
 529             continue;
 530
 531         if (IS_GRAPHIC_CHAR(pOptDesc->optValue)) {
 532             printf(zOptionFlag, pOptDesc->optValue);
 533             emit_action(pOpts, pOptDesc);
 534         }
 535     }
 536     printf(UNK_OPT_FMT, FLAG_STR, pOpts->pzPROGNAME);
 537 }
 538
 539
 540 /*
 541  *  Emit the match text for a long option
 542  */
 543 static void
 544 emit_match_expr(char const * pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts)
 545 {
 546     tOptDesc* pOD = pOpts->pOptDesc;
 547     int       oCt = pOpts->optCt;
 548     int       min = 1;
 549     char      zName[ 256 ];
 550     char*     pz  = zName;
 551
 552     for (;;) {
 553         int matchCt = 0;
 554
 555         /*
 556          *  Omit the current option, Documentation opts and compiled out opts.
 557          */
 558         if ((pOD == pCurOpt) || SKIP_OPT(pOD)){
 559             if (--oCt <= 0)
 560                 break;
 561             pOD++;
 562             continue;
 563         }
 564
 565         /*
 566          *  Check each character of the name case insensitively.
 567          *  They must not be the same.  They cannot be, because it would
 568          *  not compile correctly if they were.
 569          */
 570         while (  toupper(pOD->pz_Name[matchCt])
 571               == toupper(pzMatchName[matchCt]))
 572             matchCt++;
 573
 574         if (matchCt > min)
 575             min = matchCt;
 576
 577         /*
 578          *  Check the disablement name, too.
 579          */
 580         if (pOD->pz_DisableName != NULL) {
 581             matchCt = 0;
 582             while (  toupper(pOD->pz_DisableName[matchCt])
 583                   == toupper(pzMatchName[matchCt]))
 584                 matchCt++;
 585             if (matchCt > min)
 586                 min = matchCt;
 587         }
 588         if (--oCt <= 0)
 589             break;
 590         pOD++;
 591     }
 592
 593     /*
 594      *  IF the 'min' is all or one short of the name length,
 595      *  THEN the entire string must be matched.
 596      */
 597     if (  (pzMatchName[min  ] == NUL)
 598        || (pzMatchName[min+1] == NUL) )
 599         printf(zOptionFullName, pzMatchName);
 600
 601     else {
 602         int matchCt = 0;
 603         for (; matchCt <= min; matchCt++)
 604             *pz++ = pzMatchName[matchCt];
 605
 606         for (;;) {
 607             *pz = NUL;
 608             printf(zOptionPartName, zName);
 609             *pz++ = pzMatchName[matchCt++];
 610             if (pzMatchName[matchCt] == NUL) {
 611                 *pz = NUL;
 612                 printf(zOptionFullName, zName);
 613                 break;
 614             }
 615         }
 616     }
 617 }
 618
 619
 620 /*
 621  *  Emit GNU-standard long option handling code
 622  */
 623 static void
 624 emitLong(tOptions * pOpts)
 625 {
 626     tOptDesc* pOD = pOpts->pOptDesc;
 627     int       ct  = pOpts->optCt;
 628
 629     fputs(zOptionCase, stdout);
 630
 631     /*
 632      *  do each option, ...
 633      */
 634     do  {
 635         /*
 636          *  Documentation & compiled-out options
 637          */
 638         if (SKIP_OPT(pOD))
 639             continue;
 640
 641         emit_match_expr(pOD->pz_Name, pOD, pOpts);
 642         emit_action(pOpts, pOD);
 643
 644         /*
 645          *  Now, do the same thing for the disablement version of the option.
 646          */
 647         if (pOD->pz_DisableName != NULL) {
 648             emit_match_expr(pOD->pz_DisableName, pOD, pOpts);
 649             emit_inaction(pOpts, pOD);
 650         }
 651     } while (pOD++, --ct > 0);
 652
 653     printf(UNK_OPT_FMT, OPTION_STR, pOpts->pzPROGNAME);
 654 }
 655
 656
 657 static void
 658 open_out(char const * pzFile)
 659 {
 660     FILE* fp;
 661     char* pzData = NULL;
 662     struct stat stbf;
 663
 664     do  {
 665         char*    pzScan;
 666         size_t sizeLeft;
 667
 668         /*
 669          *  IF we cannot stat the file,
 670          *  THEN assume we are creating a new file.
 671          *       Skip the loading of the old data.
 672          */
 673         if (stat(pzFile, &stbf) != 0)
 674             break;
 675
 676         /*
 677          *  The file must be a regular file
 678          */
 679         if (! S_ISREG(stbf.st_mode)) {
 680             fprintf(stderr, zNotFile, pzFile);
 681             exit(EXIT_FAILURE);
 682         }
 683
 684         pzData = AGALOC(stbf.st_size + 1, "f data");
 685         fp = fopen(pzFile, "r" FOPEN_BINARY_FLAG);
 686
 687         sizeLeft = (unsigned)stbf.st_size;
 688         pzScan   = pzData;
 689
 690         /*
 691          *  Read in all the data as fast as our OS will let us.
 692          */
 693         for (;;) {
 694             int inct = fread((void*)pzScan, (size_t)1, sizeLeft, fp);
 695             if (inct == 0)
 696                 break;
 697
 698             pzScan   += inct;
 699             sizeLeft -= inct;
 700
 701             if (sizeLeft == 0)
 702                 break;
 703         }
 704
 705         /*
 706          *  NUL-terminate the leader and look for the trailer
 707          */
 708         *pzScan = NUL;
 709         fclose(fp);
 710         pzScan  = strstr(pzData, START_MARK);
 711         if (pzScan == NULL) {
 712             script_trailer = pzData;
 713             break;
 714         }
 715
 716         *(pzScan++) = NUL;
 717         pzScan  = strstr(pzScan, END_MARK);
 718         if (pzScan == NULL) {
 719             script_trailer = pzData;
 720             break;
 721         }
 722
 723         /*
 724          *  Check to see if the data contains our marker.
 725          *  If it does, then we will skip over it
 726          */
 727         script_trailer = pzScan + END_MARK_LEN;
 728         script_leader  = pzData;
 729     } while (false);
 730
 731     if (freopen(pzFile, "w" FOPEN_BINARY_FLAG, stdout) != stdout) {
 732         fprintf(stderr, zFreopenFail, errno, strerror(errno));
 733         exit(EXIT_FAILURE);
 734     }
 735 }
 736
 737
 738 /*=export_func genshelloptUsage
 739  * private:
 740  * what: The usage function for the genshellopt generated program
 741  *
 742  * arg:  + tOptions* + pOpts    + program options descriptor +
 743  * arg:  + int       + exitCode + usage text type to produce +
 744  *
 745  * doc:
 746  *  This function is used to create the usage strings for the option
 747  *  processing shell script code.  Two child processes are spawned
 748  *  each emitting the usage text in either the short (error exit)
 749  *  style or the long style.  The generated program will capture this
 750  *  and create shell script variables containing the two types of text.
 751 =*/
 752 void
 753 genshelloptUsage(tOptions * pOpts, int exitCode)
 754 {
 755 #if ! defined(HAVE_WORKING_FORK)
 756     optionUsage(pOpts, exitCode);
 757 #else
 758     /*
 759      *  IF not EXIT_SUCCESS,
 760      *  THEN emit the short form of usage.
 761      */
 762     if (exitCode != EXIT_SUCCESS)
 763         optionUsage(pOpts, exitCode);
 764     fflush(stderr);
 765     fflush(stdout);
 766     if (ferror(stdout) || ferror(stderr))
 767         exit(EXIT_FAILURE);
 768
 769     option_usage_fp = stdout;
 770
 771     /*
 772      *  First, print our usage
 773      */
 774     switch (fork()) {
 775     case -1:
 776         optionUsage(pOpts, EXIT_FAILURE);
 777         /* NOTREACHED */
 778
 779     case 0:
 780         pagerState = PAGER_STATE_CHILD;
 781         optionUsage(pOpts, EXIT_SUCCESS);
 782         /* NOTREACHED */
 783         _exit(EXIT_FAILURE);
 784
 785     default:
 786     {
 787         int  sts;
 788         wait(&sts);
 789     }
 790     }
 791
 792     /*
 793      *  Generate the pzProgName, since optionProcess() normally
 794      *  gets it from the command line
 795      */
 796     {
 797         char *  pz;
 798         char ** pp = (char **)(void *)&(optionParseShellOptions->pzProgName);
 799         AGDUPSTR(pz, optionParseShellOptions->pzPROGNAME, "prog name");
 800         *pp = pz;
 801         while (*pz != NUL) {
 802             *pz = tolower(*pz);
 803             pz++;
 804         }
 805     }
 806
 807     /*
 808      *  Separate the makeshell usage from the client usage
 809      */
 810     fprintf(option_usage_fp, zGenshell, optionParseShellOptions->pzProgName);
 811     fflush(option_usage_fp);
 812
 813     /*
 814      *  Now, print the client usage.
 815      */
 816     switch (fork()) {
 817     case 0:
 818         pagerState = PAGER_STATE_CHILD;
 819         /*FALLTHROUGH*/
 820     case -1:
 821         optionUsage(optionParseShellOptions, EXIT_FAILURE);
 822
 823     default:
 824     {
 825         int  sts;
 826         wait(&sts);
 827     }
 828     }
 829
 830     fflush(stdout);
 831     if (ferror(stdout)) {
 832         fputs(zOutputFail, stderr);
 833         exit(EXIT_FAILURE);
 834     }
 835
 836     exit(EXIT_SUCCESS);
 837 #endif
 838 }
 839
 840 /*
 841  * Local Variables:
 842  * mode: C
 843  * c-file-style: "stroustrup"
 844  * indent-tabs-mode: nil
 845  * End:
 846  * end of autoopts/makeshell.c */