Annotation of embedaddon/ntp/sntp/libopts/usage.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * \file usage.c
4: *
5: * Time-stamp: "2011-02-01 14:42:37 bkorb"
6: *
7: * This module implements the default usage procedure for
8: * Automated Options. It may be overridden, of course.
9: *
10: * Sort options:
11: --start=END-[S]TATIC-FORWARD --patt='^/\*($|[^:])' \
12: --out=xx.c key='^[a-zA-Z0-9_]+\(' --trail='^/\*:' \
13: --spac=2 --input=usage.c
14: */
15:
16: /*
17: * This file is part of AutoOpts, a companion to AutoGen.
18: * AutoOpts is free software.
19: * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved
20: *
21: * AutoOpts is available under any one of two licenses. The license
22: * in use must be one of these two and the choice is under the control
23: * of the user of the license.
24: *
25: * The GNU Lesser General Public License, version 3 or later
26: * See the files "COPYING.lgplv3" and "COPYING.gplv3"
27: *
28: * The Modified Berkeley Software Distribution License
29: * See the file "COPYING.mbsd"
30: *
31: * These files have the following md5sums:
32: *
33: * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3
34: * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3
35: * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd
36: */
37:
38: #define OPTPROC_L_N_S (OPTPROC_LONGOPT | OPTPROC_SHORTOPT)
39:
40: /* = = = START-STATIC-FORWARD = = = */
41: static void
42: set_usage_flags(tOptions * opts, char const * flg_txt);
43:
44: static inline ag_bool
45: do_gnu_usage(tOptions * pOpts);
46:
47: static inline ag_bool
48: skip_misuse_usage(tOptions * pOpts);
49:
50: static void
51: print_usage_details(tOptions * opts, int exit_code);
52:
53: static void
54: prt_extd_usage(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT);
55:
56: static void
57: prt_ini_list(char const * const * papz, ag_bool * pInitIntro,
58: char const * pzRc, char const * pzPN);
59:
60: static void
61: prt_preamble(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT);
62:
63: static void
64: prt_one_usage(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT);
65:
66: static void
67: prt_opt_usage(tOptions * pOpts, int ex_code, char const * pOptTitle);
68:
69: static void
70: prt_prog_detail(tOptions* pOptions);
71:
72: static int
73: setGnuOptFmts(tOptions* pOpts, tCC** ppT);
74:
75: static int
76: setStdOptFmts(tOptions* pOpts, tCC** ppT);
77: /* = = = END-STATIC-FORWARD = = = */
78:
79: /*
80: * NB: no entry may be a prefix of another entry
81: */
82: #define AOFLAG_TABLE \
83: _aof_(gnu, OPTPROC_GNUUSAGE ) \
84: _aof_(autoopts, ~OPTPROC_GNUUSAGE) \
85: _aof_(no_misuse_usage, OPTPROC_MISUSE ) \
86: _aof_(misuse_usage, ~OPTPROC_MISUSE )
87:
88: static void
89: set_usage_flags(tOptions * opts, char const * flg_txt)
90: {
91: typedef struct {
92: size_t fnm_len;
93: uint32_t fnm_mask;
94: char const * fnm_name;
95: } ao_flag_names_t;
96:
97: # define _aof_(_n, _f) AOUF_ ## _n ## _ID,
98: typedef enum { AOFLAG_TABLE AOUF_COUNT } ao_flag_id_t;
99: # undef _aof_
100:
101: # define _aof_(_n, _f) AOUF_ ## _n = (1 << AOUF_ ## _n ## _ID),
102: typedef enum { AOFLAG_TABLE } ao_flags_t;
103: # undef _aof_
104:
105: # define _aof_(_n, _f) { sizeof(#_n)-1, _f, #_n },
106: static ao_flag_names_t const fn_table[AOUF_COUNT] = {
107: AOFLAG_TABLE
108: };
109: # undef _aof_
110:
111: ao_flags_t flg = 0;
112:
113: if (flg_txt == NULL) {
114: flg_txt = getenv("AUTOOPTS_USAGE");
115: if (flg_txt == NULL)
116: return;
117: }
118:
119: while (IS_WHITESPACE_CHAR(*flg_txt)) flg_txt++;
120: if (*flg_txt == NUL)
121: return;
122:
123: for (;;) {
124: int ix = 0;
125: ao_flag_names_t const * fnt = fn_table;
126:
127: for (;;) {
128: if (strneqvcmp(flg_txt, fnt->fnm_name, fnt->fnm_len) == 0)
129: break;
130: if (++ix >= AOUF_COUNT)
131: return;
132: fnt++;
133: }
134:
135: /*
136: * Make sure we have a full match. Look for whitespace,
137: * a comma, or a NUL byte.
138: */
139: if (! IS_END_LIST_ENTRY_CHAR(flg_txt[fnt->fnm_len]))
140: return;
141:
142: flg |= 1 << ix;
143: flg_txt += fnt->fnm_len;
144: while (IS_WHITESPACE_CHAR(*flg_txt)) flg_txt++;
145:
146: if (*flg_txt == NUL)
147: break;
148:
149: if (*flg_txt == ',') {
150: /*
151: * skip the comma and following white space
152: */
153: while (IS_WHITESPACE_CHAR(*++flg_txt)) ;
154: if (*flg_txt == NUL)
155: break;
156: }
157: }
158:
159: {
160: ao_flag_names_t const * fnm = fn_table;
161:
162: while (flg != 0) {
163: if ((flg & 1) != 0) {
164: if ((fnm->fnm_mask & OPTPROC_LONGOPT) != 0)
165: opts->fOptSet &= fnm->fnm_mask;
166: else opts->fOptSet |= fnm->fnm_mask;
167: }
168: flg >>= 1;
169: fnm++;
170: }
171: }
172: }
173:
174: /*
175: * Figure out if we should try to format usage text sort-of like
176: * the way many GNU programs do.
177: */
178: static inline ag_bool
179: do_gnu_usage(tOptions * pOpts)
180: {
181: return (pOpts->fOptSet & OPTPROC_GNUUSAGE) ? AG_TRUE : AG_FALSE;
182: }
183:
184: /*
185: * Figure out if we should try to format usage text sort-of like
186: * the way many GNU programs do.
187: */
188: static inline ag_bool
189: skip_misuse_usage(tOptions * pOpts)
190: {
191: return (pOpts->fOptSet & OPTPROC_MISUSE) ? AG_TRUE : AG_FALSE;
192: }
193:
194:
195: /*=export_func optionOnlyUsage
196: *
197: * what: Print usage text for just the options
198: * arg: + tOptions* + pOpts + program options descriptor +
199: * arg: + int + ex_code + exit code for calling exit(3) +
200: *
201: * doc:
202: * This routine will print only the usage for each option.
203: * This function may be used when the emitted usage must incorporate
204: * information not available to AutoOpts.
205: =*/
206: void
207: optionOnlyUsage(tOptions * pOpts, int ex_code)
208: {
209: char const * pOptTitle = NULL;
210:
211: set_usage_flags(pOpts, NULL);
212: if ((ex_code != EXIT_SUCCESS) &&
213: skip_misuse_usage(pOpts))
214: return;
215:
216: /*
217: * Determine which header and which option formatting strings to use
218: */
219: if (do_gnu_usage(pOpts)) {
220: (void)setGnuOptFmts(pOpts, &pOptTitle);
221: }
222: else {
223: (void)setStdOptFmts(pOpts, &pOptTitle);
224: }
225:
226: prt_opt_usage(pOpts, ex_code, pOptTitle);
227:
228: fflush(option_usage_fp);
229: if (ferror(option_usage_fp) != 0) {
230: fputs(zOutputFail, stderr);
231: exit(EXIT_FAILURE);
232: }
233: }
234:
235: static void
236: print_usage_details(tOptions * opts, int exit_code)
237: {
238: {
239: char const * pOptTitle = NULL;
240:
241: /*
242: * Determine which header and which option formatting strings to use
243: */
244: if (do_gnu_usage(opts)) {
245: int flen = setGnuOptFmts(opts, &pOptTitle);
246: sprintf(zOptFmtLine, zFmtFmt, flen);
247: fputc('\n', option_usage_fp);
248: }
249: else {
250: int flen = setStdOptFmts(opts, &pOptTitle);
251: sprintf(zOptFmtLine, zFmtFmt, flen);
252:
253: /*
254: * When we exit with EXIT_SUCCESS and the first option is a doc
255: * option, we do *NOT* want to emit the column headers.
256: * Otherwise, we do.
257: */
258: if ( (exit_code != EXIT_SUCCESS)
259: || ((opts->pOptDesc->fOptState & OPTST_DOCUMENT) == 0) )
260:
261: fputs(pOptTitle, option_usage_fp);
262: }
263:
264: prt_opt_usage(opts, exit_code, pOptTitle);
265: }
266:
267: /*
268: * Describe the mechanics of denoting the options
269: */
270: switch (opts->fOptSet & OPTPROC_L_N_S) {
271: case OPTPROC_L_N_S: fputs(zFlagOkay, option_usage_fp); break;
272: case OPTPROC_SHORTOPT: break;
273: case OPTPROC_LONGOPT: fputs(zNoFlags, option_usage_fp); break;
274: case 0: fputs(zOptsOnly, option_usage_fp); break;
275: }
276:
277: if ((opts->fOptSet & OPTPROC_NUM_OPT) != 0)
278: fputs(zNumberOpt, option_usage_fp);
279:
280: if ((opts->fOptSet & OPTPROC_REORDER) != 0)
281: fputs(zReorder, option_usage_fp);
282:
283: if (opts->pzExplain != NULL)
284: fputs(opts->pzExplain, option_usage_fp);
285:
286: /*
287: * IF the user is asking for help (thus exiting with SUCCESS),
288: * THEN see what additional information we can provide.
289: */
290: if (exit_code == EXIT_SUCCESS)
291: prt_prog_detail(opts);
292:
293: /*
294: * Give bug notification preference to the packager information
295: */
296: if (HAS_pzPkgDataDir(opts) && (opts->pzPackager != NULL))
297: fputs(opts->pzPackager, option_usage_fp);
298:
299: else if (opts->pzBugAddr != NULL)
300: fprintf(option_usage_fp, zPlsSendBugs, opts->pzBugAddr);
301:
302: fflush(option_usage_fp);
303:
304: if (ferror(option_usage_fp) != 0) {
305: fputs(zOutputFail, stderr);
306: exit(EXIT_FAILURE);
307: }
308: }
309:
310:
311: /*=export_func optionUsage
312: * private:
313: *
314: * what: Print usage text
315: * arg: + tOptions* + pOptions + program options descriptor +
316: * arg: + int + exitCode + exit code for calling exit(3) +
317: *
318: * doc:
319: * This routine will print usage in both GNU-standard and AutoOpts-expanded
320: * formats. The descriptor specifies the default, but AUTOOPTS_USAGE will
321: * over-ride this, providing the value of it is set to either "gnu" or
322: * "autoopts". This routine will @strong{not} return.
323: *
324: * If "exitCode" is "EX_USAGE" (normally 64), then output will to to stdout
325: * and the actual exit code will be "EXIT_SUCCESS".
326: =*/
327: void
328: optionUsage(tOptions * pOptions, int usage_exit_code)
329: {
330: int exit_code =
331: (usage_exit_code == EX_USAGE) ? EXIT_SUCCESS : usage_exit_code;
332:
333: displayEnum = AG_FALSE;
334:
335: /*
336: * Paged usage will preset option_usage_fp to an output file.
337: * If it hasn't already been set, then set it to standard output
338: * on successful exit (help was requested), otherwise error out.
339: *
340: * Test the version before obtaining pzFullUsage or pzShortUsage.
341: * These fields do not exist before revision 30.
342: */
343: {
344: char const * pz;
345:
346: if (exit_code == EXIT_SUCCESS) {
347: pz = (pOptions->structVersion >= 30 * 4096)
348: ? pOptions->pzFullUsage : NULL;
349:
350: if (option_usage_fp == NULL)
351: option_usage_fp = stdout;
352: } else {
353: pz = (pOptions->structVersion >= 30 * 4096)
354: ? pOptions->pzShortUsage : NULL;
355:
356: if (option_usage_fp == NULL)
357: option_usage_fp = stderr;
358: }
359:
360: if (pz != NULL) {
361: fputs(pz, option_usage_fp);
362: exit(exit_code);
363: }
364: }
365:
366: fprintf(option_usage_fp, pOptions->pzUsageTitle, pOptions->pzProgName);
367: set_usage_flags(pOptions, NULL);
368:
369: if ((exit_code == EXIT_SUCCESS) ||
370: (! skip_misuse_usage(pOptions)))
371:
372: print_usage_details(pOptions, usage_exit_code);
373:
374: exit(exit_code);
375: }
376:
377:
378: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
379: *
380: * PER OPTION TYPE USAGE INFORMATION
381: */
382: static void
383: prt_extd_usage(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT)
384: {
385: /*
386: * IF there are option conflicts or dependencies,
387: * THEN print them here.
388: */
389: if ( (pOD->pOptMust != NULL)
390: || (pOD->pOptCant != NULL) ) {
391:
392: fputs(zTabHyp, option_usage_fp);
393:
394: /*
395: * DEPENDENCIES:
396: */
397: if (pOD->pOptMust != NULL) {
398: const int* pOptNo = pOD->pOptMust;
399:
400: fputs(zReqThese, option_usage_fp);
401: for (;;) {
402: fprintf(option_usage_fp, zTabout,
403: pOptions->pOptDesc[*pOptNo].pz_Name);
404: if (*++pOptNo == NO_EQUIVALENT)
405: break;
406: }
407:
408: if (pOD->pOptCant != NULL)
409: fputs(zTabHypAnd, option_usage_fp);
410: }
411:
412: /*
413: * CONFLICTS:
414: */
415: if (pOD->pOptCant != NULL) {
416: const int* pOptNo = pOD->pOptCant;
417:
418: fputs(zProhib, option_usage_fp);
419: for (;;) {
420: fprintf(option_usage_fp, zTabout,
421: pOptions->pOptDesc[*pOptNo].pz_Name);
422: if (*++pOptNo == NO_EQUIVALENT)
423: break;
424: }
425: }
426: }
427:
428: /*
429: * IF there is a disablement string
430: * THEN print the disablement info
431: */
432: if (pOD->pz_DisableName != NULL )
433: fprintf(option_usage_fp, zDis, pOD->pz_DisableName);
434:
435: /*
436: * Check for argument types that have callbacks with magical properties
437: */
438: switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
439: case OPARG_TYPE_NUMERIC:
440: /*
441: * IF the numeric option has a special callback,
442: * THEN call it, requesting the range or other special info
443: */
444: if ( (pOD->pOptProc != NULL)
445: && (pOD->pOptProc != optionNumericVal) ) {
446: (*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
447: }
448: break;
449:
450: case OPARG_TYPE_FILE:
451: (*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
452: break;
453: }
454:
455: /*
456: * IF the option defaults to being enabled,
457: * THEN print that out
458: */
459: if (pOD->fOptState & OPTST_INITENABLED)
460: fputs(zEnab, option_usage_fp);
461:
462: /*
463: * IF the option is in an equivalence class
464: * AND not the designated lead
465: * THEN print equivalence and leave it at that.
466: */
467: if ( (pOD->optEquivIndex != NO_EQUIVALENT)
468: && (pOD->optEquivIndex != pOD->optActualIndex ) ) {
469: fprintf(option_usage_fp, zAlt,
470: pOptions->pOptDesc[ pOD->optEquivIndex ].pz_Name);
471: return;
472: }
473:
474: /*
475: * IF this particular option can NOT be preset
476: * AND some form of presetting IS allowed,
477: * AND it is not an auto-managed option (e.g. --help, et al.)
478: * THEN advise that this option may not be preset.
479: */
480: if ( ((pOD->fOptState & OPTST_NO_INIT) != 0)
481: && ( (pOptions->papzHomeList != NULL)
482: || (pOptions->pzPROGNAME != NULL)
483: )
484: && (pOD->optIndex < pOptions->presetOptCt)
485: )
486:
487: fputs(zNoPreset, option_usage_fp);
488:
489: /*
490: * Print the appearance requirements.
491: */
492: if (OPTST_GET_ARGTYPE(pOD->fOptState) == OPARG_TYPE_MEMBERSHIP)
493: fputs(zMembers, option_usage_fp);
494:
495: else switch (pOD->optMinCt) {
496: case 1:
497: case 0:
498: switch (pOD->optMaxCt) {
499: case 0: fputs(zPreset, option_usage_fp); break;
500: case NOLIMIT: fputs(zNoLim, option_usage_fp); break;
501: case 1: break;
502: /*
503: * IF the max is more than one but limited, print "UP TO" message
504: */
505: default: fprintf(option_usage_fp, zUpTo, pOD->optMaxCt); break;
506: }
507: break;
508:
509: default:
510: /*
511: * More than one is required. Print the range.
512: */
513: fprintf(option_usage_fp, zMust, pOD->optMinCt, pOD->optMaxCt);
514: }
515:
516: if ( NAMED_OPTS(pOptions)
517: && (pOptions->specOptIdx.default_opt == pOD->optIndex))
518: fputs(zDefaultOpt, option_usage_fp);
519: }
520:
521:
522: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
523: *
524: * Figure out where all the initialization files might live.
525: * This requires translating some environment variables and
526: * testing to see if a name is a directory or a file. It's
527: * squishy, but important to tell users how to find these files.
528: */
529: static void
530: prt_ini_list(char const * const * papz, ag_bool * pInitIntro,
531: char const * pzRc, char const * pzPN)
532: {
533: char zPath[AG_PATH_MAX+1];
534:
535: if (papz == NULL)
536: return;
537:
538: fputs(zPresetIntro, option_usage_fp);
539: *pInitIntro = AG_FALSE;
540:
541: for (;;) {
542: char const * pzPath = *(papz++);
543: char const * pzReal = zPath;
544:
545: if (pzPath == NULL)
546: break;
547:
548: /*
549: * Ignore any invalid paths
550: */
551: if (! optionMakePath(zPath, (int)sizeof(zPath), pzPath, pzPN))
552: pzReal = pzPath;
553:
554: /*
555: * Expand paths that are relative to the executable or installation
556: * directories. Leave alone paths that use environment variables.
557: */
558: else if ((*pzPath == '$')
559: && ((pzPath[1] == '$') || (pzPath[1] == '@')))
560: pzPath = pzReal;
561:
562: /*
563: * Print the name of the "homerc" file. If the "rcfile" name is
564: * not empty, we may or may not print that, too...
565: */
566: fprintf(option_usage_fp, zPathFmt, pzPath);
567: if (*pzRc != NUL) {
568: struct stat sb;
569:
570: /*
571: * IF the "homerc" file is a directory,
572: * then append the "rcfile" name.
573: */
574: if ((stat(pzReal, &sb) == 0) && S_ISDIR(sb.st_mode)) {
575: fputc(DIRCH, option_usage_fp);
576: fputs(pzRc, option_usage_fp);
577: }
578: }
579:
580: fputc('\n', option_usage_fp);
581: }
582: }
583:
584:
585: static void
586: prt_preamble(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT)
587: {
588: /*
589: * Flag prefix: IF no flags at all, then omit it. If not printable
590: * (not allowed for this option), then blank, else print it.
591: * Follow it with a comma if we are doing GNU usage and long
592: * opts are to be printed too.
593: */
594: if ((pOptions->fOptSet & OPTPROC_SHORTOPT) == 0)
595: fputs(pAT->pzSpc, option_usage_fp);
596:
597: else if (! IS_GRAPHIC_CHAR(pOD->optValue)) {
598: if ( (pOptions->fOptSet & (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
599: == (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
600: fputc(' ', option_usage_fp);
601: fputs(pAT->pzNoF, option_usage_fp);
602:
603: } else {
604: fprintf(option_usage_fp, " -%c", pOD->optValue);
605: if ( (pOptions->fOptSet & (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
606: == (OPTPROC_GNUUSAGE|OPTPROC_LONGOPT))
607: fputs(", ", option_usage_fp);
608: }
609: }
610:
611: /*
612: * Print the usage information for a single option.
613: */
614: static void
615: prt_one_usage(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT)
616: {
617: prt_preamble(pOptions, pOD, pAT);
618:
619: {
620: char z[ 80 ];
621: char const * pzArgType;
622:
623: /*
624: * Determine the argument type string first on its usage, then,
625: * when the option argument is required, base the type string on the
626: * argument type.
627: */
628: if (pOD->fOptState & OPTST_ARG_OPTIONAL) {
629: pzArgType = pAT->pzOpt;
630:
631: } else switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
632: case OPARG_TYPE_NONE: pzArgType = pAT->pzNo; break;
633: case OPARG_TYPE_ENUMERATION: pzArgType = pAT->pzKey; break;
634: case OPARG_TYPE_FILE: pzArgType = pAT->pzFile; break;
635: case OPARG_TYPE_MEMBERSHIP: pzArgType = pAT->pzKeyL; break;
636: case OPARG_TYPE_BOOLEAN: pzArgType = pAT->pzBool; break;
637: case OPARG_TYPE_NUMERIC: pzArgType = pAT->pzNum; break;
638: case OPARG_TYPE_HIERARCHY: pzArgType = pAT->pzNest; break;
639: case OPARG_TYPE_STRING: pzArgType = pAT->pzStr; break;
640: case OPARG_TYPE_TIME: pzArgType = pAT->pzTime; break;
641: default: goto bogus_desc;
642: }
643:
644: snprintf(z, sizeof(z), pAT->pzOptFmt, pzArgType, pOD->pz_Name,
645: (pOD->optMinCt != 0) ? pAT->pzReq : pAT->pzOpt);
646:
647: fprintf(option_usage_fp, zOptFmtLine, z, pOD->pzText);
648:
649: switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
650: case OPARG_TYPE_ENUMERATION:
651: case OPARG_TYPE_MEMBERSHIP:
652: displayEnum = (pOD->pOptProc != NULL) ? AG_TRUE : displayEnum;
653: }
654: }
655: return;
656:
657: bogus_desc:
658: fprintf(stderr, zInvalOptDesc, pOD->pz_Name);
659: exit(EX_SOFTWARE);
660: }
661:
662:
663: /*
664: * Print out the usage information for just the options.
665: */
666: static void
667: prt_opt_usage(tOptions * pOpts, int ex_code, char const * pOptTitle)
668: {
669: int ct = pOpts->optCt;
670: int optNo = 0;
671: tOptDesc * pOD = pOpts->pOptDesc;
672: int docCt = 0;
673:
674: do {
675: if ((pOD->fOptState & OPTST_NO_USAGE_MASK) != 0) {
676:
677: /*
678: * IF this is a compiled-out option
679: * *AND* usage was requested with "omitted-usage"
680: * *AND* this is NOT abbreviated usage
681: * THEN display this option.
682: */
683: if ( (pOD->fOptState == (OPTST_OMITTED | OPTST_NO_INIT))
684: && (pOD->pz_Name != NULL)
685: && (ex_code == EXIT_SUCCESS)) {
686:
687: char const * why_pz =
688: (pOD->pzText == NULL) ? zDisabledWhy : pOD->pzText;
689: prt_preamble(pOpts, pOD, &argTypes);
690: fprintf(option_usage_fp, zDisabledOpt, pOD->pz_Name, why_pz);
691: }
692:
693: continue;
694: }
695:
696: if ((pOD->fOptState & OPTST_DOCUMENT) != 0) {
697: if (ex_code == EXIT_SUCCESS) {
698: fprintf(option_usage_fp, argTypes.pzBrk, pOD->pzText,
699: pOptTitle);
700: docCt++;
701: }
702:
703: continue;
704: }
705:
706: /*
707: * IF this is the first auto-opt maintained option
708: * *AND* we are doing a full help
709: * *AND* there are documentation options
710: * *AND* the last one was not a doc option,
711: * THEN document that the remaining options are not user opts
712: */
713: if ( (pOpts->presetOptCt == optNo)
714: && (ex_code == EXIT_SUCCESS)
715: && (docCt > 0)
716: && ((pOD[-1].fOptState & OPTST_DOCUMENT) == 0) )
717: fprintf(option_usage_fp, argTypes.pzBrk, zAuto, pOptTitle);
718:
719: prt_one_usage(pOpts, pOD, &argTypes);
720:
721: /*
722: * IF we were invoked because of the --help option,
723: * THEN print all the extra info
724: */
725: if (ex_code == EXIT_SUCCESS)
726: prt_extd_usage(pOpts, pOD, &argTypes);
727:
728: } while (pOD++, optNo++, (--ct > 0));
729:
730: fputc('\n', option_usage_fp);
731: }
732:
733:
734: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
735: *
736: * PROGRAM DETAILS
737: */
738: static void
739: prt_prog_detail(tOptions* pOptions)
740: {
741: ag_bool initIntro = AG_TRUE;
742:
743: /*
744: * Display all the places we look for config files
745: */
746: prt_ini_list(pOptions->papzHomeList, &initIntro,
747: pOptions->pzRcName, pOptions->pzProgPath);
748:
749: /*
750: * Let the user know about environment variable settings
751: */
752: if ((pOptions->fOptSet & OPTPROC_ENVIRON) != 0) {
753: if (initIntro)
754: fputs(zPresetIntro, option_usage_fp);
755:
756: fprintf(option_usage_fp, zExamineFmt, pOptions->pzPROGNAME);
757: }
758:
759: /*
760: * IF we found an enumeration,
761: * THEN hunt for it again. Call the handler proc with a NULL
762: * option struct pointer. That tells it to display the keywords.
763: */
764: if (displayEnum) {
765: int ct = pOptions->optCt;
766: int optNo = 0;
767: tOptDesc* pOD = pOptions->pOptDesc;
768:
769: fputc('\n', option_usage_fp);
770: fflush(option_usage_fp);
771: do {
772: switch (OPTST_GET_ARGTYPE(pOD->fOptState)) {
773: case OPARG_TYPE_ENUMERATION:
774: case OPARG_TYPE_MEMBERSHIP:
775: (*(pOD->pOptProc))(OPTPROC_EMIT_USAGE, pOD);
776: }
777: } while (pOD++, optNo++, (--ct > 0));
778: }
779:
780: /*
781: * If there is a detail string, now is the time for that.
782: */
783: if (pOptions->pzDetail != NULL)
784: fputs(pOptions->pzDetail, option_usage_fp);
785: }
786:
787:
788: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
789: *
790: * OPTION LINE FORMATTING SETUP
791: *
792: * The "OptFmt" formats receive three arguments:
793: * 1. the type of the option's argument
794: * 2. the long name of the option
795: * 3. "YES" or "no ", depending on whether or not the option must appear
796: * on the command line.
797: * These formats are used immediately after the option flag (if used) has
798: * been printed.
799: *
800: * Set up the formatting for GNU-style output
801: */
802: static int
803: setGnuOptFmts(tOptions* pOpts, tCC** ppT)
804: {
805: int flen = 22;
806: *ppT = zNoRq_ShrtTtl;
807:
808: argTypes.pzStr = zGnuStrArg;
809: argTypes.pzReq = zOneSpace;
810: argTypes.pzNum = zGnuNumArg;
811: argTypes.pzKey = zGnuKeyArg;
812: argTypes.pzKeyL = zGnuKeyLArg;
813: argTypes.pzTime = zGnuTimeArg;
814: argTypes.pzFile = zGnuFileArg;
815: argTypes.pzBool = zGnuBoolArg;
816: argTypes.pzNest = zGnuNestArg;
817: argTypes.pzOpt = zGnuOptArg;
818: argTypes.pzNo = zOneSpace;
819: argTypes.pzBrk = zGnuBreak;
820: argTypes.pzNoF = zSixSpaces;
821: argTypes.pzSpc = zThreeSpaces;
822:
823: switch (pOpts->fOptSet & OPTPROC_L_N_S) {
824: case OPTPROC_L_N_S: argTypes.pzOptFmt = zGnuOptFmt; break;
825: case OPTPROC_LONGOPT: argTypes.pzOptFmt = zGnuOptFmt; break;
826: case 0: argTypes.pzOptFmt = zGnuOptFmt + 2; break;
827: case OPTPROC_SHORTOPT:
828: argTypes.pzOptFmt = zShrtGnuOptFmt;
829: zGnuStrArg[0] = zGnuNumArg[0] = zGnuKeyArg[0] = zGnuBoolArg[0] = ' ';
830: argTypes.pzOpt = " [arg]";
831: flen = 8;
832: break;
833: }
834:
835: return flen;
836: }
837:
838:
839: /*
840: * Standard (AutoOpts normal) option line formatting
841: */
842: static int
843: setStdOptFmts(tOptions* pOpts, tCC** ppT)
844: {
845: int flen = 0;
846:
847: argTypes.pzStr = zStdStrArg;
848: argTypes.pzReq = zStdReqArg;
849: argTypes.pzNum = zStdNumArg;
850: argTypes.pzKey = zStdKeyArg;
851: argTypes.pzKeyL = zStdKeyLArg;
852: argTypes.pzTime = zStdTimeArg;
853: argTypes.pzFile = zStdFileArg;
854: argTypes.pzBool = zStdBoolArg;
855: argTypes.pzNest = zStdNestArg;
856: argTypes.pzOpt = zStdOptArg;
857: argTypes.pzNo = zStdNoArg;
858: argTypes.pzBrk = zStdBreak;
859: argTypes.pzNoF = zFiveSpaces;
860: argTypes.pzSpc = zTwoSpaces;
861:
862: switch (pOpts->fOptSet & (OPTPROC_NO_REQ_OPT | OPTPROC_SHORTOPT)) {
863: case (OPTPROC_NO_REQ_OPT | OPTPROC_SHORTOPT):
864: *ppT = zNoRq_ShrtTtl;
865: argTypes.pzOptFmt = zNrmOptFmt;
866: flen = 19;
867: break;
868:
869: case OPTPROC_NO_REQ_OPT:
870: *ppT = zNoRq_NoShrtTtl;
871: argTypes.pzOptFmt = zNrmOptFmt;
872: flen = 19;
873: break;
874:
875: case OPTPROC_SHORTOPT:
876: *ppT = zReq_ShrtTtl;
877: argTypes.pzOptFmt = zReqOptFmt;
878: flen = 24;
879: break;
880:
881: case 0:
882: *ppT = zReq_NoShrtTtl;
883: argTypes.pzOptFmt = zReqOptFmt;
884: flen = 24;
885: }
886:
887: return flen;
888: }
889:
890:
891: /*:
892: * Local Variables:
893: * mode: C
894: * c-file-style: "stroustrup"
895: * indent-tabs-mode: nil
896: * End:
897: * 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