/** * emit the arguments as readily parsed text. * The program options are set by emitting the shell "set" command. * * @param[in] opts the program options structure */ static void print_reordering(tOptions * opts) { unsigned int ix; fputs(set_dash, stdout); for (ix = opts->curOptIdx; ix < opts->origArgCt; ix++) { fputc(' ', stdout); print_quot_str(opts->origArgVect[ ix ]); } fputs(init_optct, stdout); }
static void print_stacked_arg(tOptions * pOpts, tOptDesc * pOD) { tArgList * pAL = (tArgList *)pOD->optCookie; char const ** ppz = pAL->apzArgs; int ct = pAL->useCt; printf(zOptCookieCt, pOpts->pzPROGNAME, pOD->pz_NAME, ct); while (--ct >= 0) { printf(ARG_BY_NUM_FMT, pOpts->pzPROGNAME, pOD->pz_NAME, pAL->useCt - ct); print_quot_str(*(ppz++)); printf(EXPORT_ARG_FMT, pOpts->pzPROGNAME, pOD->pz_NAME, pAL->useCt - ct); } }
static void print_stacked_arg(tOptions * pOpts, tOptDesc * pOD) { tSCC zOptCookieCt[] = "%1$s_%2$s_CT=%3$d\nexport %1$s_%2$s_CT\n"; tArgList* pAL = (tArgList*)pOD->optCookie; tCC** ppz = pAL->apzArgs; int ct = pAL->useCt; printf(zOptCookieCt, pOpts->pzPROGNAME, pOD->pz_NAME, ct); while (--ct >= 0) { tSCC numarg_z[] = "%s_%s_%d="; tSCC end_z[] = "\nexport %s_%s_%d\n"; printf(numarg_z, pOpts->pzPROGNAME, pOD->pz_NAME, pAL->useCt - ct); print_quot_str(*(ppz++)); printf(end_z, pOpts->pzPROGNAME, pOD->pz_NAME, pAL->useCt - ct); } }
/*=export_func optionPutShell * what: write a portable shell script to parse options * private: * arg: tOptions *, pOpts, the program options descriptor * doc: This routine will emit portable shell script text for parsing * the options described in the option definitions. =*/ void optionPutShell(tOptions * pOpts) { int optIx = 0; printf(zOptCtFmt, pOpts->curOptIdx-1); do { tOptDesc * pOD = pOpts->pOptDesc + optIx; if ((pOD->fOptState & OPTST_NO_OUTPUT_MASK) != 0) continue; /* * Equivalence classes are hard to deal with. Where the * option data wind up kind of squishes around. For the purposes * of emitting shell state, they are not recommended, but we'll * do something. I guess we'll emit the equivalenced-to option * at the point in time when the base option is found. */ if (pOD->optEquivIndex != NO_EQUIVALENT) continue; /* equivalence to a different option */ /* * Equivalenced to a different option. Process the current option * as the equivalenced-to option. Keep the persistent state bits, * but copy over the set-state bits. */ if (pOD->optActualIndex != optIx) { tOptDesc * p = pOpts->pOptDesc + pOD->optActualIndex; p->optArg = pOD->optArg; p->fOptState &= OPTST_PERSISTENT_MASK; p->fOptState |= pOD->fOptState & ~OPTST_PERSISTENT_MASK; printf(zEquivMode, pOpts->pzPROGNAME, pOD->pz_NAME, p->pz_NAME); pOD = p; } /* * If the argument type is a set membership bitmask, then we always * emit the thing. We do this because it will always have some sort * of bitmask value and we need to emit the bit values. */ if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP) { print_membership(pOpts, pOD); continue; } /* * IF the option was either specified or it wakes up enabled, * then we will emit information. Otherwise, skip it. * The idea is that if someone defines an option to initialize * enabled, we should tell our shell script that it is enabled. */ if (UNUSED_OPT(pOD) && DISABLED_OPT(pOD)) continue; /* * Handle stacked arguments */ if ( (pOD->fOptState & OPTST_STACKED) && (pOD->optCookie != NULL) ) { print_stacked_arg(pOpts, pOD); continue; } /* * If the argument has been disabled, * Then set its value to the disablement string */ if ((pOD->fOptState & OPTST_DISABLED) != 0) { printf(zOptDisabl, pOpts->pzPROGNAME, pOD->pz_NAME, (pOD->pz_DisablePfx != NULL) ? pOD->pz_DisablePfx : "false"); continue; } /* * If the argument type is numeric, the last arg pointer * is really the VALUE of the string that was pointed to. */ if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_NUMERIC) { printf(zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME, (int)pOD->optArg.argInt); continue; } /* * If the argument type is an enumeration, then it is much * like a text value, except we call the callback function * to emit the value corresponding to the "optArg" number. */ if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_ENUMERATION) { print_enumeration(pOpts, pOD); continue; } /* * If the argument type is numeric, the last arg pointer * is really the VALUE of the string that was pointed to. */ if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_BOOLEAN) { printf(zFullOptFmt, pOpts->pzPROGNAME, pOD->pz_NAME, (pOD->optArg.argBool == 0) ? "false" : "true"); continue; } /* * IF the option has an empty value, * THEN we set the argument to the occurrence count. */ if ( (pOD->optArg.argString == NULL) || (pOD->optArg.argString[0] == NUL) ) { printf(zOptNumFmt, pOpts->pzPROGNAME, pOD->pz_NAME, pOD->optOccCt); continue; } /* * This option has a text value */ printf(OPT_VAL_FMT, pOpts->pzPROGNAME, pOD->pz_NAME); print_quot_str(pOD->optArg.argString); printf(OPT_END_FMT, pOpts->pzPROGNAME, pOD->pz_NAME); } while (++optIx < pOpts->presetOptCt ); if ( ((pOpts->fOptSet & OPTPROC_REORDER) != 0) && (pOpts->curOptIdx < pOpts->origArgCt)) print_reordering(pOpts); fflush(stdout); }