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