/**
* Process all the options from our current position onward. (This allows
* interspersed options and arguments for the few non-standard programs that
* require it.) Thus, do not rewind option indexes because some programs
* choose to re-invoke after a non-option.
*/
LOCAL tSuccess
doRegularOpts(tOptions* pOpts)
{
for (;;) {
tOptState optState = OPTSTATE_INITIALIZER(DEFINED);
switch (nextOption(pOpts, &optState)) {
case FAILURE: goto failed_option;
case PROBLEM: return SUCCESS; /* no more args */
case SUCCESS: break;
}
/*
* IF this is an immediate action option,
* THEN skip it (unless we are supposed to do it a second time).
*/
if (! DO_NORMALLY(optState.flags)) {
if (! DO_SECOND_TIME(optState.flags))
continue;
optState.pOD->optOccCt--; /* don't count this repetition */
}
if (! SUCCESSFUL(handle_opt(pOpts, &optState)))
break;
} failed_option:;
if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)
(*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
return FAILURE;
}
/*=export_func optionVendorOption
* private:
*
* what: Process a vendor option
* arg: + tOptions * + pOpts + program options descriptor +
* arg: + tOptDesc * + pOptDesc + the descriptor for this arg +
*
* doc:
* For POSIX specified utilities, the options are constrained to the options,
* @xref{config attributes, Program Configuration}. AutoOpts clients should
* never specify this directly. It gets referenced when the option
* definitions contain a "vendor-opt" attribute.
=*/
void
optionVendorOption(tOptions * pOpts, tOptDesc * pOD)
{
tOptState opt_st = OPTSTATE_INITIALIZER(PRESET);
char const * vopt_str = pOD->optArg.argString;
if (pOpts <= OPTPROC_EMIT_LIMIT)
return;
if ((pOD->fOptState & OPTST_RESET) != 0)
return;
if ((pOD->fOptState & OPTPROC_IMMEDIATE) == 0)
opt_st.flags = OPTST_DEFINED;
if ( ((pOpts->fOptSet & OPTPROC_VENDOR_OPT) == 0)
|| ! SUCCESSFUL(opt_find_long(pOpts, vopt_str, &opt_st))
|| ! SUCCESSFUL(get_opt_arg(pOpts, &opt_st)) )
{
fprintf(stderr, zIllVendOptStr, pOpts->pzProgName, vopt_str);
(*pOpts->pUsageProc)(pOpts, EXIT_FAILURE);
/* NOTREACHED */
_exit(EXIT_FAILURE); /* to be certain */
}
/*
* See if we are in immediate handling state.
*/
if (pOpts->fOptSet & OPTPROC_IMMEDIATE) {
/*
* See if the enclosed option is okay with that state.
*/
if (DO_IMMEDIATELY(opt_st.flags))
(void)handle_opt(pOpts, &opt_st);
} else {
/*
* non-immediate direction.
* See if the enclosed option is okay with that state.
*/
if (DO_NORMALLY(opt_st.flags) || DO_SECOND_TIME(opt_st.flags))
(void)handle_opt(pOpts, &opt_st);
}
}
static void
do_env_opt(tOptState * os, char * env_name,
tOptions * pOpts, teEnvPresetType type)
{
os->pzOptArg = getenv(env_name);
if (os->pzOptArg == NULL)
return;
os->flags = OPTST_PRESET | OPTST_ALLOC_ARG | os->pOD->fOptState;
os->optType = TOPT_UNDEFINED;
if ( (os->pOD->pz_DisablePfx != NULL)
&& (streqvcmp(os->pzOptArg, os->pOD->pz_DisablePfx) == 0)) {
os->flags |= OPTST_DISABLED;
os->pzOptArg = NULL;
}
switch (type) {
case ENV_IMM:
/*
* Process only immediate actions
*/
if (DO_IMMEDIATELY(os->flags))
break;
return;
case ENV_NON_IMM:
/*
* Process only NON immediate actions
*/
if (DO_NORMALLY(os->flags) || DO_SECOND_TIME(os->flags))
break;
return;
default: /* process everything */
break;
}
/*
* Make sure the option value string is persistent and consistent.
*
* The interpretation of the option value depends
* on the type of value argument the option takes
*/
if (OPTST_GET_ARGTYPE(os->pOD->fOptState) == OPARG_TYPE_NONE) {
/*
* Ignore any value.
*/
os->pzOptArg = NULL;
} else if (os->pzOptArg[0] == NUL) {
/*
* If the argument is the empty string and the argument is
* optional, then treat it as if the option was not specified.
*/
if ((os->pOD->fOptState & OPTST_ARG_OPTIONAL) == 0)
return;
os->pzOptArg = NULL;
} else {
AGDUPSTR(os->pzOptArg, os->pzOptArg, "option argument");
os->flags |= OPTST_ALLOC_ARG;
}
handle_opt(pOpts, os);
}
