/**
* 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);
}
