src/libopts/putshell.c

   1
   2 /**
   3  * \file putshell.c
   4  *
   5  * Time-stamp:      "2012-03-31 13:14:18 bkorb"
   6  *
   7  *  This module will interpret the options set in the tOptions
   8  *  structure and print them to standard out in a fashion that
   9  *  will allow them to be interpreted by the Bourne or Korn shells.
  10  *
  11  *  This file is part of AutoOpts, a companion to AutoGen.
  12  *  AutoOpts is free software.
  13  *  AutoOpts is Copyright (c) 1992-2012 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 /* = = = START-STATIC-FORWARD = = = */
  33 static void
  34 print_quot_str(char const * pzStr);
  35
  36 static void
  37 print_enumeration(tOptions * pOpts, tOptDesc * pOD);
  38
  39 static void
  40 print_membership(tOptions * pOpts, tOptDesc * pOD);
  41
  42 static void
  43 print_stacked_arg(tOptions * pOpts, tOptDesc * pOD);
  44
  45 static void
  46 print_reordering(tOptions * pOpts);
  47 /* = = = END-STATIC-FORWARD = = = */
  48
  49 /*
  50  *  Make sure embedded single quotes come out okay.  The initial quote has
  51  *  been emitted and the closing quote will be upon return.
  52  */
  53 static void
  54 print_quot_str(char const * pzStr)
  55 {
  56     /*
  57      *  Handle empty strings to make the rest of the logic simpler.
  58      */
  59     if ((pzStr == NULL) || (*pzStr == NUL)) {
  60         fputs(EMPTY_ARG, stdout);
  61         return;
  62     }
  63
  64     /*
  65      *  Emit any single quotes/apostrophes at the start of the string and
  66      *  bail if that is all we need to do.
  67      */
  68     while (*pzStr == '\'') {
  69         fputs(QUOT_APOS, stdout);
  70         pzStr++;
  71     }
  72     if (*pzStr == NUL)
  73         return;
  74
  75     /*
  76      *  Start the single quote string
  77      */
  78     fputc('\'', stdout);
  79     for (;;) {
  80         char const * pz = strchr(pzStr, '\'');
  81         if (pz == NULL)
  82             break;
  83
  84         /*
  85          *  Emit the string up to the single quote (apostrophe) we just found.
  86          */
  87         (void)fwrite(pzStr, (size_t)(pz - pzStr), (size_t)1, stdout);
  88         fputc('\'', stdout);
  89         pzStr = pz;
  90
  91         /*
  92          *  Emit an escaped apostrophe for every one we find.
  93          *  If that ends the string, do not re-open the single quotes.
  94          */
  95         while (*++pzStr == '\'')   fputs("\\'", stdout);
  96         if (*pzStr == NUL)
  97             return;
  98
  99         fputc('\'', stdout);
 100     }
 101
 102     /*
 103      *  If we broke out of the loop, we must still emit the remaining text
 104      *  and then close the single quote string.
 105      */
 106     fputs(pzStr, stdout);
 107     fputc('\'', stdout);
 108 }
 109
 110 static void
 111 print_enumeration(tOptions * pOpts, tOptDesc * pOD)
 112 {
 113     uintptr_t e_val = pOD->optArg.argEnum;
 114     printf(OPT_VAL_FMT, pOpts->pzPROGNAME, pOD->pz_NAME);
 115
 116     /*
 117      *  Convert value to string, print that and restore numeric value.
 118      */
 119     (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);
 120     printf(QUOT_ARG_FMT, pOD->optArg.argString);
 121     if (pOD->fOptState & OPTST_ALLOC_ARG)
 122         AGFREE(pOD->optArg.argString);
 123     pOD->optArg.argEnum = e_val;
 124
 125     printf(OPT_END_FMT, pOpts->pzPROGNAME, pOD->pz_NAME);
 126 }
 127
 128 static void
 129 print_membership(tOptions * pOpts, tOptDesc * pOD)
 130 {
 131     char const * pz;
 132     uintptr_t val = 1;
 133     printf(zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
 134            (int)(uintptr_t)(pOD->optCookie));
 135     pOD->optCookie = (void*)(uintptr_t)~0UL;
 136     (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD);
 137
 138     /*
 139      *  We are building the typeset list.  The list returned starts with
 140      *  'none + ' for use by option saving stuff.  We must ignore that.
 141      */
 142     pz = pOD->optArg.argString + 7;
 143     while (*pz != NUL) {
 144         printf("typeset -x -i %s_", pOD->pz_NAME);
 145         pz = SPN_PLUS_N_SPACE_CHARS(pz);
 146
 147         for (;;) {
 148             int ch = *(pz++);
 149             if (IS_LOWER_CASE_CHAR(ch))   fputc(toupper(ch), stdout);
 150             else if (IS_UPPER_CASE_CHAR(ch))   fputc(ch, stdout);
 151             else if (IS_PLUS_N_SPACE_CHAR(ch)) goto name_done;
 152             else if (ch == NUL)        { pz--; goto name_done; }
 153             else fputc('_', stdout);
 154         } name_done:;
 155         printf(SHOW_VAL_FMT, (unsigned long)val);
 156         val <<= 1;
 157     }
 158
 159     AGFREE(pOD->optArg.argString);
 160     pOD->optArg.argString = NULL;
 161     pOD->fOptState &= ~OPTST_ALLOC_ARG;
 162 }
 163
 164 static void
 165 print_stacked_arg(tOptions * pOpts, tOptDesc * pOD)
 166 {
 167     tArgList*    pAL = (tArgList*)pOD->optCookie;
 168     tCC**        ppz = pAL->apzArgs;
 169     int          ct  = pAL->useCt;
 170
 171     printf(zOptCookieCt, pOpts->pzPROGNAME, pOD->pz_NAME, ct);
 172
 173     while (--ct >= 0) {
 174         printf(ARG_BY_NUM_FMT, pOpts->pzPROGNAME, pOD->pz_NAME,
 175                pAL->useCt - ct);
 176         print_quot_str(*(ppz++));
 177         printf(EXPORT_ARG_FMT, pOpts->pzPROGNAME, pOD->pz_NAME,
 178                pAL->useCt - ct);
 179     }
 180 }
 181
 182 static void
 183 print_reordering(tOptions * pOpts)
 184 {
 185     unsigned int optIx;
 186
 187     fputs(set_dash, stdout);
 188
 189     for (optIx = pOpts->curOptIdx;
 190          optIx < pOpts->origArgCt;
 191          optIx++) {
 192
 193         char* pzArg = pOpts->origArgVect[ optIx ];
 194
 195         if (strchr(pzArg, '\'') == NULL)
 196             printf(arg_fmt, pzArg);
 197
 198         else {
 199             fputs(" '", stdout);
 200             for (;;) {
 201                 char ch = *(pzArg++);
 202                 switch (ch) {
 203                 case '\'':  fputs(apostrophy, stdout); break;
 204                 case NUL:   goto arg_done;
 205                 default:    fputc(ch, stdout); break;
 206                 }
 207             } arg_done:;
 208             fputc('\'', stdout);
 209         }
 210     }
 211     fputs(init_optct, stdout);
 212 }
 213
 214 /*=export_func  optionPutShell
 215  * what:  write a portable shell script to parse options
 216  * private:
 217  * arg:   tOptions*, pOpts, the program options descriptor
 218  * doc:   This routine will emit portable shell script text for parsing
 219  *        the options described in the option definitions.
 220 =*/
 221 void
 222 optionPutShell(tOptions* pOpts)
 223 {
 224     int  optIx = 0;
 225
 226     printf(zOptCtFmt, pOpts->curOptIdx-1);
 227
 228     do  {
 229         tOptDesc* pOD = pOpts->pOptDesc + optIx;
 230
 231         if ((pOD->fOptState & OPTST_NO_OUTPUT_MASK) != 0)
 232             continue;
 233
 234         /*
 235          *  Equivalence classes are hard to deal with.  Where the
 236          *  option data wind up kind of squishes around.  For the purposes
 237          *  of emitting shell state, they are not recommended, but we'll
 238          *  do something.  I guess we'll emit the equivalenced-to option
 239          *  at the point in time when the base option is found.
 240          */
 241         if (pOD->optEquivIndex != NO_EQUIVALENT)
 242             continue; /* equivalence to a different option */
 243
 244         /*
 245          *  Equivalenced to a different option.  Process the current option
 246          *  as the equivalenced-to option.  Keep the persistent state bits,
 247          *  but copy over the set-state bits.
 248          */
 249         if (pOD->optActualIndex != optIx) {
 250             tOptDesc* p   = pOpts->pOptDesc + pOD->optActualIndex;
 251             p->optArg     = pOD->optArg;
 252             p->fOptState &= OPTST_PERSISTENT_MASK;
 253             p->fOptState |= pOD->fOptState & ~OPTST_PERSISTENT_MASK;
 254             printf(zEquivMode, pOpts->pzPROGNAME, pOD->pz_NAME, p->pz_NAME);
 255             pOD = p;
 256         }
 257
 258         /*
 259          *  If the argument type is a set membership bitmask, then we always
 260          *  emit the thing.  We do this because it will always have some sort
 261          *  of bitmask value and we need to emit the bit values.
 262          */
 263         if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP) {
 264             print_membership(pOpts, pOD);
 265             continue;
 266         }
 267
 268         /*
 269          *  IF the option was either specified or it wakes up enabled,
 270          *  then we will emit information.  Otherwise, skip it.
 271          *  The idea is that if someone defines an option to initialize
 272          *  enabled, we should tell our shell script that it is enabled.
 273          */
 274         if (UNUSED_OPT(pOD) && DISABLED_OPT(pOD))
 275             continue;
 276
 277         /*
 278          *  Handle stacked arguments
 279          */
 280         if (  (pOD->fOptState & OPTST_STACKED)
 281            && (pOD->optCookie != NULL) )  {
 282             print_stacked_arg(pOpts, pOD);
 283             continue;
 284         }
 285
 286         /*
 287          *  If the argument has been disabled,
 288          *  Then set its value to the disablement string
 289          */
 290         if ((pOD->fOptState & OPTST_DISABLED) != 0) {
 291             printf(zOptDisabl, pOpts->pzPROGNAME, pOD->pz_NAME,
 292                    (pOD->pz_DisablePfx != NULL)
 293                    ? pOD->pz_DisablePfx : "false");
 294             continue;
 295         }
 296
 297         /*
 298          *  If the argument type is numeric, the last arg pointer
 299          *  is really the VALUE of the string that was pointed to.
 300          */
 301         if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_NUMERIC) {
 302             printf(zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
 303                    (int)pOD->optArg.argInt);
 304             continue;
 305         }
 306
 307         /*
 308          *  If the argument type is an enumeration, then it is much
 309          *  like a text value, except we call the callback function
 310          *  to emit the value corresponding to the "optArg" number.
 311          */
 312         if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_ENUMERATION) {
 313             print_enumeration(pOpts, pOD);
 314             continue;
 315         }
 316
 317         /*
 318          *  If the argument type is numeric, the last arg pointer
 319          *  is really the VALUE of the string that was pointed to.
 320          */
 321         if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_BOOLEAN) {
 322             printf(zFullOptFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
 323                    (pOD->optArg.argBool == 0) ? "false" : "true");
 324             continue;
 325         }
 326
 327         /*
 328          *  IF the option has an empty value,
 329          *  THEN we set the argument to the occurrence count.
 330          */
 331         if (  (pOD->optArg.argString == NULL)
 332            || (pOD->optArg.argString[0] == NUL) ) {
 333
 334             printf(zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME,
 335                    pOD->optOccCt);
 336             continue;
 337         }
 338
 339         /*
 340          *  This option has a text value
 341          */
 342         printf(OPT_VAL_FMT, pOpts->pzPROGNAME, pOD->pz_NAME);
 343         print_quot_str(pOD->optArg.argString);
 344         printf(OPT_END_FMT, pOpts->pzPROGNAME, pOD->pz_NAME);
 345
 346     } while (++optIx < pOpts->presetOptCt );
 347
 348     if (  ((pOpts->fOptSet & OPTPROC_REORDER) != 0)
 349        && (pOpts->curOptIdx < pOpts->origArgCt))
 350         print_reordering(pOpts);
 351
 352     fflush(stdout);
 353 }
 354
 355 /*
 356  * Local Variables:
 357  * mode: C
 358  * c-file-style: "stroustrup"
 359  * indent-tabs-mode: nil
 360  * End:
 361  * end of autoopts/putshell.c */