/*
* \file usage.c
*
* Time-stamp: "2011-02-01 14:42:37 bkorb"
*
* This module implements the default usage procedure for
* Automated Options. It may be overridden, of course.
*
* Sort options:
--start=END-[S]TATIC-FORWARD --patt='^/\*($|[^:])' \
--out=xx.c key='^[a-zA-Z0-9_]+\(' --trail='^/\*:' \
--spac=2 --input=usage.c
*/
/*
* This file is part of AutoOpts, a companion to AutoGen.
* AutoOpts is free software.
* AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved
*
* AutoOpts is available under any one of two licenses. The license
* in use must be one of these two and the choice is under the control
* of the user of the license.
*
* The GNU Lesser General Public License, version 3 or later
* See the files "COPYING.lgplv3" and "COPYING.gplv3"
*
* The Modified Berkeley Software Distribution License
* See the file "COPYING.mbsd"
*
* These files have the following md5sums:
*
* 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
* 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
* 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
*/
#define OPTPROC_L_N_S (OPTPROC_LONGOPT | OPTPROC_SHORTOPT)
/* = = = START-STATIC-FORWARD = = = */
static void
set_usage_flags(tOptions * opts, char const * flg_txt);
static inline ag_bool
do_gnu_usage(tOptions * pOpts);
static inline ag_bool
skip_misuse_usage(tOptions * pOpts);
static void
print_usage_details(tOptions * opts, int exit_code);
static void
prt_extd_usage(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT);
static void
prt_ini_list(char const * const * papz, ag_bool * pInitIntro,
char const * pzRc, char const * pzPN);
static void
prt_preamble(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT);
static void
prt_one_usage(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT);
static void
prt_opt_usage(tOptions * pOpts, int ex_code, char const * pOptTitle);
static void
prt_prog_detail(tOptions* pOptions);
static int
setGnuOptFmts(tOptions* pOpts, tCC** ppT);
static int
setStdOptFmts(tOptions* pOpts, tCC** ppT);
/* = = = END-STATIC-FORWARD = = = */
/*
* NB: no entry may be a prefix of another entry
*/
#define AOFLAG_TABLE \
_aof_(gnu, OPTPROC_GNUUSAGE ) \
_aof_(autoopts, ~OPTPROC_GNUUSAGE) \
_aof_(no_misuse_usage, OPTPROC_MISUSE ) \
_aof_(misuse_usage, ~OPTPROC_MISUSE )
static void
set_usage_flags(tOptions * opts, char const * flg_txt)
{
typedef struct {
size_t fnm_len;
uint32_t fnm_mask;
char const * fnm_name;
} ao_flag_names_t;
# define _aof_(_n, _f) AOUF_ ## _n ## _ID,
typedef enum { AOFLAG_TABLE AOUF_COUNT } ao_flag_id_t;
# undef _aof_
# define _aof_(_n, _f) AOUF_ ## _n = (1 << AOUF_ ## _n ## _ID),
typedef enum { AOFLAG_TABLE } ao_flags_t;
# undef _aof_
# define _aof_(_n, _f) { sizeof(#_n)-1, _f, #_n },
static ao_flag_names_t const fn_table[AOUF_COUNT] = {
AOFLAG_TABLE
};
# undef _aof_
ao_flags_t flg = 0;
if (flg_txt == NULL) {
flg_txt = getenv("AUTOOPTS_USAGE");
if (flg_txt == NULL)
return;
}
while (IS_WHITESPACE_CHAR(*flg_txt)) flg_txt++;
if (*flg_txt == NUL)
return;
for (;;) {
int ix = 0;
ao_flag_names_t const * fnt = fn_table;
for (;;) {
if (strneqvcmp(flg_txt, fnt->fnm_name, fnt->fnm_len) == 0)
break;
if (++ix >= AOUF_COUNT)
return;
fnt++;
}
/*
* Make sure we have a full match. Look for whitespace,
* a comma, or a NUL byte.
*/
if (! IS_END_LIST_ENTRY_CHAR(flg_txt[fnt->fnm_len]))
return;
flg |= 1 << ix;
flg_txt += fnt->fnm_len;
while (IS_WHITESPACE_CHAR(*flg_txt)) flg_txt++;
if (*flg_txt == NUL)
break;
if (*flg_txt == ',') {
/*
* skip the comma and following white space
*/
while (IS_WHITESPACE_CHAR(*++flg_txt)) ;
if (*flg_txt == NUL)
break;
}
}
{
ao_flag_names_t const * fnm = fn_table;
while (flg != 0) {
if ((flg & 1) != 0) {
if ((fnm->fnm_mask & OPTPROC_LONGOPT) != 0)
opts->fOptSet &= fnm->fnm_mask;
else opts->fOptSet |= fnm->fnm_mask;
}
flg >>= 1;
fnm++;
}
}
}
/*
* Figure out if we should try to format usage text sort-of like
* the way many GNU programs do.
*/
static inline ag_bool
do_gnu_usage(tOptions * pOpts)
{
return (pOpts->fOptSet & OPTPROC_GNUUSAGE) ? AG_TRUE : AG_FALSE;
}
/*
* Figure out if we should try to format usage text sort-of like
* the way many GNU programs do.
*/
static inline ag_bool
skip_misuse_usage(tOptions * pOpts)
{
return (pOpts->fOptSet & OPTPROC_MISUSE) ? AG_TRUE : AG_FALSE;
}
/*=export_func optionOnlyUsage
*
* what: Print usage text for just the options
* arg: + tOptions* + pOpts + program options descriptor +
* arg: + int + ex_code + exit code for calling exit(3) +
*
* doc:
* This routine will print only the usage for each option.
* This function may be used when the emitted usage must incorporate
* information not available to AutoOpts.
=*/
void
optionOnlyUsage(tOptions * pOpts, int ex_code)
{
char const * pOptTitle = NULL;
set_usage_flags(pOpts, NULL);
if ((ex_code != EXIT_SUCCESS) &&
skip_misuse_usage(pOpts))
return;
/*
* Determine which header and which option formatting strings to use
*/
if (do_gnu_usage(pOpts)) {
(void)setGnuOptFmts(pOpts, &pOptTitle);
}
else {
(void)setStdOptFmts(pOpts, &pOptTitle);
}
prt_opt_usage(pOpts, ex_code, pOptTitle);
fflush(option_usage_fp);
if (ferror(option_usage_fp) != 0) {
fputs(zOutputFail, stderr);
exit(EXIT_FAILURE);
}
}
static void
print_usage_details(tOptions * opts, int exit_code)
{
{
char const * pOptTitle = NULL;
/*
* Determine which header and which option formatting strings to use
*/
if (do_gnu_usage(opts)) {
int flen = setGnuOptFmts(opts, &pOptTitle);
sprintf(zOptFmtLine, zFmtFmt, flen);
fputc('\n', option_usage_fp);
}
else {
int flen = setStdOptFmts(opts, &pOptTitle);
sprintf(zOptFmtLine, zFmtFmt, flen);
/*
* When we exit with EXIT_SUCCESS and the first option is a doc
* option, we do *NOT* want to emit the column headers.
* Otherwise, we do.
*/
if ( (exit_code != EXIT_SUCCESS)
|| ((opts->pOptDesc->fOptState & OPTST_DOCUMENT) == 0) )
fputs(pOptTitle, option_usage_fp);
}
prt_opt_usage(opts, exit_code, pOptTitle);
}
/*
* Describe the mechanics of denoting the options
*/
switch (opts->fOptSet & OPTPROC_L_N_S) {
case OPTPROC_L_N_S: fputs(zFlagOkay, option_usage_fp); break;
case OPTPROC_SHORTOPT: break;
case OPTPROC_LONGOPT: fputs(zNoFlags, option_usage_fp); break;
case 0: fputs(zOptsOnly, option_usage_fp); break;
}
if ((opts->fOptSet & OPTPROC_NUM_OPT) != 0)
fputs(zNumberOpt, option_usage_fp);
if ((opts->fOptSet & OPTPROC_REORDER) != 0)
fputs(zReorder, option_usage_fp);
if (opts->pzExplain != NULL)
fputs(opts->pzExplain, option_usage_fp);
/*
* IF the user is asking for help (thus exiting with SUCCESS),
* THEN see what additional information we can provide.
*/
if (exit_code == EXIT_SUCCESS)
prt_prog_detail(opts);
/*
* Give bug notification preference to the packager information
*/
if (HAS_pzPkgDataDir(opts) && (opts->pzPackager != NULL))
fputs(opts->pzPackager, option_usage_fp);
else if (opts->pzBugAddr != NULL)
fprintf(option_usage_fp, zPlsSendBugs, opts->pzBugAddr);
fflush(option_usage_fp);
if (ferror(option_usage_fp) != 0) {
fputs(zOutputFail, stderr);
exit(EXIT_FAILURE);
}
}
/*=export_func optionUsage
* private:
*
* what: Print usage text
* arg: + tOptions* + pOptions + program options descriptor +
* arg: + int + exitCode + exit code for calling exit(3) +
*
* doc:
* This routine will print usage in both GNU-standard and AutoOpts-expanded
* formats. The descriptor specifies the default, but AUTOOPTS_USAGE will
* over-ride this, providing the value of it is set to either "gnu" or
* "autoopts". This routine will @strong{not} return.
*
* If "exitCode" is "EX_USAGE" (normally 64), then output will to to stdout
* and the actual exit code will be "EXIT_SUCCESS".
=*/
void
optionUsage(tOptions * pOptions, int usage_exit_code)
{
int exit_code =
(usage_exit_code == EX_USAGE) ? EXIT_SUCCESS : usage_exit_code;
displayEnum = AG_FALSE;
/*
* Paged usage will preset option_usage_fp to an output file.
* If it hasn't already been set, then set it to standard output
* on successful exit (help was requested), otherwise error out.
*
* Test the version before obtaining pzFullUsage or pzShortUsage.
* These fields do not exist before revision 30.
*/
{
char const * pz;
if (exit_code == EXIT_SUCCESS) {
pz = (pOptions->structVersion >= 30 * 4096)
? pOptions->pzFullUsage : NULL;
if (option_usage_fp == NULL)
option_usage_fp = stdout;
} else {
pz = (pOptions->structVersion >= 30 * 4096)
? pOptions->pzShortUsage : NULL;
if (option_usage_fp == NULL)
option_usage_fp = stderr;
}
if (pz != NULL) {
fputs(pz, option_usage_fp);
exit(exit_code);
}
}
fprintf(option_usage_fp, pOptions->pzUsageTitle, pOptions->pzProgName);
set_usage_flags(pOptions, NULL);
if ((exit_code == EXIT_SUCCESS) ||
(! skip_misuse_usage(pOptions)))
print_usage_details(pOptions, usage_exit_code);
exit(exit_code);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* PER OPTION TYPE USAGE INFORMATION
*/
static void
prt_extd_usage(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT)
{
/*
* IF there are option conflicts or dependencies,
* THEN print them here.
*/
if ( (pOD->pOptMust != NULL)
|| (pOD->pOptCant != NULL) ) {
fputs(zTabHyp, option_usage_fp);
/*
* DEPENDENCIES:
*/
if (pOD->pOptMust != NULL) {
const int* pOptNo = pOD->pOptMust;
fputs(zReqThese, option_usage_fp);
for (;;) {
fprintf(option_usage_fp, zTabout,
pOptions->pOptDesc[*pOptNo].pz_Name);
if (*++pOptNo == NO_EQUIVALENT)
break;
}
if (pOD->pOptCant != NULL)
fputs(zTabHypAnd, option_usage_fp);
}
/*
* CONFLICTS:
*/
if (pOD->pOptCant != NULL) {
const int* pOptNo = pOD->pOptCant;
fputs(zProhib, option_usage_fp);
for (;;) {
fprintf(option_usage_fp, zTabout,
pOptions->pOptDesc[*pOptNo].pz_Name);
if (*++pOptNo == NO_EQUIVALENT)
break;
}
}
}
/*
* IF there is a disablement string
* THEN print the disablement info
*/
if (pOD->pz_DisableName != NULL )
fprintf(option_usage_fp, zDis, pOD->pz_DisableName);
/*
* Check for argument types that have callbacks with magical properties
*/
switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
case OPARG_TYPE_NUMERIC:
/*
* IF the numeric option has a special callback,
* THEN call it, requesting the range or other special info
*/
if ( (pOD->pOptProc != NULL)
&& (pOD->pOptProc != optionNumericVal) ) {
(*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
}
break;
case OPARG_TYPE_FILE:
(*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
break;
}
/*
* IF the option defaults to being enabled,
* THEN print that out
*/
if (pOD->fOptState & OPTST_INITENABLED)
fputs(zEnab, option_usage_fp);
/*
* IF the option is in an equivalence class
* AND not the designated lead
* THEN print equivalence and leave it at that.
*/
if ( (pOD->optEquivIndex != NO_EQUIVALENT)
&& (pOD->optEquivIndex != pOD->optActualIndex ) ) {
fprintf(option_usage_fp, zAlt,
pOptions->pOptDesc[ pOD->optEquivIndex ].pz_Name);
return;
}
/*
* IF this particular option can NOT be preset
* AND some form of presetting IS allowed,
* AND it is not an auto-managed option (e.g. --help, et al.)
* THEN advise that this option may not be preset.
*/
if ( ((pOD->fOptState & OPTST_NO_INIT) != 0)
&& ( (pOptions->papzHomeList != NULL)
|| (pOptions->pzPROGNAME != NULL)
)
&& (pOD->optIndex < pOptions->presetOptCt)
)
fputs(zNoPreset, option_usage_fp);
/*
* Print the appearance requirements.
*/
if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP)
fputs(zMembers, option_usage_fp);
else switch (pOD->optMinCt) {
case 1:
case 0:
switch (pOD->optMaxCt) {
case 0: fputs(zPreset, option_usage_fp); break;
case NOLIMIT: fputs(zNoLim, option_usage_fp); break;
case 1: break;
/*
* IF the max is more than one but limited, print "UP TO" message
*/
default: fprintf(option_usage_fp, zUpTo, pOD->optMaxCt); break;
}
break;
default:
/*
* More than one is required. Print the range.
*/
fprintf(option_usage_fp, zMust, pOD->optMinCt, pOD->optMaxCt);
}
if ( NAMED_OPTS(pOptions)
&& (pOptions->specOptIdx.default_opt == pOD->optIndex))
fputs(zDefaultOpt, option_usage_fp);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Figure out where all the initialization files might live.
* This requires translating some environment variables and
* testing to see if a name is a directory or a file. It's
* squishy, but important to tell users how to find these files.
*/
static void
prt_ini_list(char const * const * papz, ag_bool * pInitIntro,
char const * pzRc, char const * pzPN)
{
char zPath[AG_PATH_MAX+1];
if (papz == NULL)
return;
fputs(zPresetIntro, option_usage_fp);
*pInitIntro = AG_FALSE;
for (;;) {
char const * pzPath = *(papz++);
char const * pzReal = zPath;
if (pzPath == NULL)
break;
/*
* Ignore any invalid paths
*/
if (! optionMakePath(zPath, (int)sizeof(zPath), pzPath, pzPN))
pzReal = pzPath;
/*
* Expand paths that are relative to the executable or installation
* directories. Leave alone paths that use environment variables.
*/
else if ((*pzPath == '$')
&& ((pzPath[1] == '$') || (pzPath[1] == '@')))
pzPath = pzReal;
/*
* Print the name of the "homerc" file. If the "rcfile" name is
* not empty, we may or may not print that, too...
*/
fprintf(option_usage_fp, zPathFmt, pzPath);
if (*pzRc != NUL) {
struct stat sb;
/*
* IF the "homerc" file is a directory,
* then append the "rcfile" name.
*/
if ((stat(pzReal, &sb) == 0) && S_ISDIR(sb.st_mode)) {
fputc(DIRCH, option_usage_fp);
fputs(pzRc, option_usage_fp);
}
}
fputc('\n', option_usage_fp);
}
}
static void
prt_preamble(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT)
{
/*
* Flag prefix: IF no flags at all, then omit it. If not printable
* (not allowed for this option), then blank, else print it.
* Follow it with a comma if we are doing GNU usage and long
* opts are to be printed too.
*/
if ((pOptions->fOptSet & OPTPROC_SHORTOPT) == 0)
fputs(pAT->pzSpc, option_usage_fp);
else if (! IS_GRAPHIC_CHAR(pOD->optValue)) {
if ( (pOptions->fOptSet & (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
== (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
fputc(' ', option_usage_fp);
fputs(pAT->pzNoF, option_usage_fp);
} else {
fprintf(option_usage_fp, " -%c", pOD->optValue);
if ( (pOptions->fOptSet & (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
== (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
fputs(", ", option_usage_fp);
}
}
/*
* Print the usage information for a single option.
*/
static void
prt_one_usage(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT)
{
prt_preamble(pOptions, pOD, pAT);
{
char z[ 80 ];
char const * pzArgType;
/*
* Determine the argument type string first on its usage, then,
* when the option argument is required, base the type string on the
* argument type.
*/
if (pOD->fOptState & OPTST_ARG_OPTIONAL) {
pzArgType = pAT->pzOpt;
} else switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
case OPARG_TYPE_NONE: pzArgType = pAT->pzNo; break;
case OPARG_TYPE_ENUMERATION: pzArgType = pAT->pzKey; break;
case OPARG_TYPE_FILE: pzArgType = pAT->pzFile; break;
case OPARG_TYPE_MEMBERSHIP: pzArgType = pAT->pzKeyL; break;
case OPARG_TYPE_BOOLEAN: pzArgType = pAT->pzBool; break;
case OPARG_TYPE_NUMERIC: pzArgType = pAT->pzNum; break;
case OPARG_TYPE_HIERARCHY: pzArgType = pAT->pzNest; break;
case OPARG_TYPE_STRING: pzArgType = pAT->pzStr; break;
case OPARG_TYPE_TIME: pzArgType = pAT->pzTime; break;
default: goto bogus_desc;
}
snprintf(z, sizeof(z), pAT->pzOptFmt, pzArgType, pOD->pz_Name,
(pOD->optMinCt != 0) ? pAT->pzReq : pAT->pzOpt);
fprintf(option_usage_fp, zOptFmtLine, z, pOD->pzText);
switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
case OPARG_TYPE_ENUMERATION:
case OPARG_TYPE_MEMBERSHIP:
displayEnum = (pOD->pOptProc != NULL) ? AG_TRUE : displayEnum;
}
}
return;
bogus_desc:
fprintf(stderr, zInvalOptDesc, pOD->pz_Name);
exit(EX_SOFTWARE);
}
/*
* Print out the usage information for just the options.
*/
static void
prt_opt_usage(tOptions * pOpts, int ex_code, char const * pOptTitle)
{
int ct = pOpts->optCt;
int optNo = 0;
tOptDesc * pOD = pOpts->pOptDesc;
int docCt = 0;
do {
if ((pOD->fOptState & OPTST_NO_USAGE_MASK) != 0) {
/*
* IF this is a compiled-out option
* *AND* usage was requested with "omitted-usage"
* *AND* this is NOT abbreviated usage
* THEN display this option.
*/
if ( (pOD->fOptState == (OPTST_OMITTED | OPTST_NO_INIT))
&& (pOD->pz_Name != NULL)
&& (ex_code == EXIT_SUCCESS)) {
char const * why_pz =
(pOD->pzText == NULL) ? zDisabledWhy : pOD->pzText;
prt_preamble(pOpts, pOD, &argTypes);
fprintf(option_usage_fp, zDisabledOpt, pOD->pz_Name, why_pz);
}
continue;
}
if ((pOD->fOptState & OPTST_DOCUMENT) != 0) {
if (ex_code == EXIT_SUCCESS) {
fprintf(option_usage_fp, argTypes.pzBrk, pOD->pzText,
pOptTitle);
docCt++;
}
continue;
}
/*
* IF this is the first auto-opt maintained option
* *AND* we are doing a full help
* *AND* there are documentation options
* *AND* the last one was not a doc option,
* THEN document that the remaining options are not user opts
*/
if ( (pOpts->presetOptCt == optNo)
&& (ex_code == EXIT_SUCCESS)
&& (docCt > 0)
&& ((pOD[-1].fOptState & OPTST_DOCUMENT) == 0) )
fprintf(option_usage_fp, argTypes.pzBrk, zAuto, pOptTitle);
prt_one_usage(pOpts, pOD, &argTypes);
/*
* IF we were invoked because of the --help option,
* THEN print all the extra info
*/
if (ex_code == EXIT_SUCCESS)
prt_extd_usage(pOpts, pOD, &argTypes);
} while (pOD++, optNo++, (--ct > 0));
fputc('\n', option_usage_fp);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* PROGRAM DETAILS
*/
static void
prt_prog_detail(tOptions* pOptions)
{
ag_bool initIntro = AG_TRUE;
/*
* Display all the places we look for config files
*/
prt_ini_list(pOptions->papzHomeList, &initIntro,
pOptions->pzRcName, pOptions->pzProgPath);
/*
* Let the user know about environment variable settings
*/
if ((pOptions->fOptSet & OPTPROC_ENVIRON) != 0) {
if (initIntro)
fputs(zPresetIntro, option_usage_fp);
fprintf(option_usage_fp, zExamineFmt, pOptions->pzPROGNAME);
}
/*
* IF we found an enumeration,
* THEN hunt for it again. Call the handler proc with a NULL
* option struct pointer. That tells it to display the keywords.
*/
if (displayEnum) {
int ct = pOptions->optCt;
int optNo = 0;
tOptDesc* pOD = pOptions->pOptDesc;
fputc('\n', option_usage_fp);
fflush(option_usage_fp);
do {
switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
case OPARG_TYPE_ENUMERATION:
case OPARG_TYPE_MEMBERSHIP:
(*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
}
} while (pOD++, optNo++, (--ct > 0));
}
/*
* If there is a detail string, now is the time for that.
*/
if (pOptions->pzDetail != NULL)
fputs(pOptions->pzDetail, option_usage_fp);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* OPTION LINE FORMATTING SETUP
*
* The "OptFmt" formats receive three arguments:
* 1. the type of the option's argument
* 2. the long name of the option
* 3. "YES" or "no ", depending on whether or not the option must appear
* on the command line.
* These formats are used immediately after the option flag (if used) has
* been printed.
*
* Set up the formatting for GNU-style output
*/
static int
setGnuOptFmts(tOptions* pOpts, tCC** ppT)
{
int flen = 22;
*ppT = zNoRq_ShrtTtl;
argTypes.pzStr = zGnuStrArg;
argTypes.pzReq = zOneSpace;
argTypes.pzNum = zGnuNumArg;
argTypes.pzKey = zGnuKeyArg;
argTypes.pzKeyL = zGnuKeyLArg;
argTypes.pzTime = zGnuTimeArg;
argTypes.pzFile = zGnuFileArg;
argTypes.pzBool = zGnuBoolArg;
argTypes.pzNest = zGnuNestArg;
argTypes.pzOpt = zGnuOptArg;
argTypes.pzNo = zOneSpace;
argTypes.pzBrk = zGnuBreak;
argTypes.pzNoF = zSixSpaces;
argTypes.pzSpc = zThreeSpaces;
switch (pOpts->fOptSet & OPTPROC_L_N_S) {
case OPTPROC_L_N_S: argTypes.pzOptFmt = zGnuOptFmt; break;
case OPTPROC_LONGOPT: argTypes.pzOptFmt = zGnuOptFmt; break;
case 0: argTypes.pzOptFmt = zGnuOptFmt + 2; break;
case OPTPROC_SHORTOPT:
argTypes.pzOptFmt = zShrtGnuOptFmt;
zGnuStrArg[0] = zGnuNumArg[0] = zGnuKeyArg[0] = zGnuBoolArg[0] = ' ';
argTypes.pzOpt = " [arg]";
flen = 8;
break;
}
return flen;
}
/*
* Standard (AutoOpts normal) option line formatting
*/
static int
setStdOptFmts(tOptions* pOpts, tCC** ppT)
{
int flen = 0;
argTypes.pzStr = zStdStrArg;
argTypes.pzReq = zStdReqArg;
argTypes.pzNum = zStdNumArg;
argTypes.pzKey = zStdKeyArg;
argTypes.pzKeyL = zStdKeyLArg;
argTypes.pzTime = zStdTimeArg;
argTypes.pzFile = zStdFileArg;
argTypes.pzBool = zStdBoolArg;
argTypes.pzNest = zStdNestArg;
argTypes.pzOpt = zStdOptArg;
argTypes.pzNo = zStdNoArg;
argTypes.pzBrk = zStdBreak;
argTypes.pzNoF = zFiveSpaces;
argTypes.pzSpc = zTwoSpaces;
switch (pOpts->fOptSet & (OPTPROC_NO_REQ_OPT | OPTPROC_SHORTOPT)) {
case (OPTPROC_NO_REQ_OPT | OPTPROC_SHORTOPT):
*ppT = zNoRq_ShrtTtl;
argTypes.pzOptFmt = zNrmOptFmt;
flen = 19;
break;
case OPTPROC_NO_REQ_OPT:
*ppT = zNoRq_NoShrtTtl;
argTypes.pzOptFmt = zNrmOptFmt;
flen = 19;
break;
case OPTPROC_SHORTOPT:
*ppT = zReq_ShrtTtl;
argTypes.pzOptFmt = zReqOptFmt;
flen = 24;
break;
case 0:
*ppT = zReq_NoShrtTtl;
argTypes.pzOptFmt = zReqOptFmt;
flen = 24;
}
return flen;
}
/*:
* Local Variables:
* mode: C
* c-file-style: "stroustrup"
* indent-tabs-mode: nil
* End:
* end of autoopts/usage.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to usage.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / sntp / libopts