1: /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 4 -*- */
2:
3: /** \ingroup popt
4: * \file popt/popthelp.c
5: */
6:
7: /* (C) 1998-2002 Red Hat, Inc. -- Licensing details are in the COPYING
8: file accompanying popt source distributions, available from
9: ftp://ftp.rpm.org/pub/rpm/dist. */
10:
11: #include "system.h"
12:
13: /*#define POPT_WCHAR_HACK*/
14: #ifdef POPT_WCHAR_HACK
15: #include <wchar.h> /* for mbsrtowcs */
16: /*@access mbstate_t @*/
17: #endif
18: #include "poptint.h"
19:
20: /*@access poptContext@*/
21:
22: /**
23: * Display arguments.
24: * @param con context
25: * @param foo (unused)
26: * @param key option(s)
27: * @param arg (unused)
28: * @param data (unused)
29: */
30: static void displayArgs(poptContext con,
31: /*@unused@*/ UNUSED(enum poptCallbackReason foo),
32: struct poptOption * key,
33: /*@unused@*/ UNUSED(const char * arg), /*@unused@*/ UNUSED(void * data))
34: /*@globals fileSystem@*/
35: /*@modifies fileSystem@*/
36: {
37: if (key->shortName == '?')
38: poptPrintHelp(con, stdout, 0);
39: else
40: poptPrintUsage(con, stdout, 0);
41: exit(0);
42: }
43:
44: #ifdef NOTYET
45: /*@unchecked@*/
46: static int show_option_defaults = 0;
47: #endif
48:
49: /**
50: * Empty table marker to enable displaying popt alias/exec options.
51: */
52: /*@observer@*/ /*@unchecked@*/
53: struct poptOption poptAliasOptions[] = {
54: POPT_TABLEEND
55: };
56:
57: /**
58: * Auto help table options.
59: */
60: /*@-castfcnptr@*/
61: /*@observer@*/ /*@unchecked@*/
62: struct poptOption poptHelpOptions[] = {
63: { NULL, '\0', POPT_ARG_CALLBACK, (void *)&displayArgs, '\0', NULL, NULL },
64: { "help", '?', 0, NULL, '?', N_("Show this help message"), NULL },
65: { "usage", '\0', 0, NULL, 'u', N_("Display brief usage message"), NULL },
66: POPT_TABLEEND
67: } ;
68:
69: /*@observer@*/ /*@unchecked@*/
70: static struct poptOption poptHelpOptions2[] = {
71: /*@-readonlytrans@*/
72: { NULL, '\0', POPT_ARG_INTL_DOMAIN, PACKAGE, 0, NULL, NULL},
73: /*@=readonlytrans@*/
74: { NULL, '\0', POPT_ARG_CALLBACK, (void *)&displayArgs, '\0', NULL, NULL },
75: { "help", '?', 0, NULL, '?', N_("Show this help message"), NULL },
76: { "usage", '\0', 0, NULL, 'u', N_("Display brief usage message"), NULL },
77: #ifdef NOTYET
78: { "defaults", '\0', POPT_ARG_NONE, &show_option_defaults, 0,
79: N_("Display option defaults in message"), NULL },
80: #endif
81: POPT_TABLEEND
82: } ;
83:
84: /*@observer@*/ /*@unchecked@*/
85: struct poptOption * poptHelpOptionsI18N = poptHelpOptions2;
86: /*@=castfcnptr@*/
87:
88: /**
89: * @param table option(s)
90: */
91: /*@observer@*/ /*@null@*/ static const char *
92: getTableTranslationDomain(/*@null@*/ const struct poptOption *table)
93: /*@*/
94: {
95: const struct poptOption *opt;
96:
97: if (table != NULL)
98: for (opt = table; opt->longName || opt->shortName || opt->arg; opt++) {
99: if (opt->argInfo == POPT_ARG_INTL_DOMAIN)
100: return opt->arg;
101: }
102: return NULL;
103: }
104:
105: /**
106: * @param opt option(s)
107: * @param translation_domain translation domain
108: */
109: /*@observer@*/ /*@null@*/ static const char *
110: getArgDescrip(const struct poptOption * opt,
111: /*@-paramuse@*/ /* FIX: i18n macros disabled with lclint */
112: /*@null@*/ UNUSED(const char * translation_domain))
113: /*@=paramuse@*/
114: /*@*/
115: {
116: if (!(opt->argInfo & POPT_ARG_MASK)) return NULL;
117:
118: if (opt == (poptHelpOptions + 1) || opt == (poptHelpOptions + 2))
119: if (opt->argDescrip) return POPT_(opt->argDescrip);
120:
121: if (opt->argDescrip) return D_(translation_domain, opt->argDescrip);
122:
123: switch (opt->argInfo & POPT_ARG_MASK) {
124: /*case POPT_ARG_NONE: return POPT_("NONE");*/ /* impossible */
125: #ifdef DYING
126: case POPT_ARG_VAL: return POPT_("VAL");
127: #else
128: case POPT_ARG_VAL: return NULL;
129: #endif
130: case POPT_ARG_INT: return POPT_("INT");
131: case POPT_ARG_LONG: return POPT_("LONG");
132: case POPT_ARG_STRING: return POPT_("STRING");
133: case POPT_ARG_FLOAT: return POPT_("FLOAT");
134: case POPT_ARG_DOUBLE: return POPT_("DOUBLE");
135: default: return POPT_("ARG");
136: }
137: }
138:
139: /**
140: * Display default value for an option.
141: * @param lineLength display positions remaining
142: * @param opt option(s)
143: * @param translation_domain translation domain
144: * @return
145: */
146: static /*@only@*/ /*@null@*/ char *
147: singleOptionDefaultValue(size_t lineLength,
148: const struct poptOption * opt,
149: /*@-paramuse@*/ /* FIX: i18n macros disabled with lclint */
150: /*@null@*/ UNUSED(const char * translation_domain))
151: /*@=paramuse@*/
152: /*@*/
153: {
154: const char * defstr = D_(translation_domain, "default");
155: size_t limit, bufsize = 4*lineLength + 1;
156: char * le = malloc(bufsize);
157: char * l = le;
158:
159: if (le == NULL) return NULL; /* XXX can't happen */
160: /*@-boundswrite@*/
161: *le++ = '(';
162: le += strlcpy(le, defstr, bufsize - 3);
163: *le++ = ':';
164: *le++ = ' ';
165: limit = bufsize - (le - l) - 1; /* -1 for closing paren */
166: if (opt->arg) /* XXX programmer error */
167: switch (opt->argInfo & POPT_ARG_MASK) {
168: case POPT_ARG_VAL:
169: case POPT_ARG_INT:
170: { long aLong = *((int *)opt->arg);
171: le += snprintf(le, limit, "%ld", aLong);
172: } break;
173: case POPT_ARG_LONG:
174: { long aLong = *((long *)opt->arg);
175: le += snprintf(le, limit, "%ld", aLong);
176: } break;
177: case POPT_ARG_FLOAT:
178: { double aDouble = *((float *)opt->arg);
179: le += snprintf(le, limit, "%g", aDouble);
180: } break;
181: case POPT_ARG_DOUBLE:
182: { double aDouble = *((double *)opt->arg);
183: le += snprintf(le, limit, "%g", aDouble);
184: } break;
185: case POPT_ARG_STRING:
186: { const char * s = *(const char **)opt->arg;
187: if (s == NULL) {
188: le += strlcpy(le, "null", limit);
189: } else {
190: size_t len;
191: limit -= 2; /* make room for quotes */
192: *le++ = '"';
193: len = strlcpy(le, s, limit);
194: if (len >= limit) {
195: le += limit - 3 - 1;
196: *le++ = '.'; *le++ = '.'; *le++ = '.';
197: } else
198: le += len;
199: *le++ = '"';
200: }
201: } break;
202: case POPT_ARG_NONE:
203: default:
204: l = _free(l);
205: return NULL;
206: /*@notreached@*/ break;
207: }
208: *le++ = ')';
209: *le = '\0';
210: /*@=boundswrite@*/
211:
212: return l;
213: }
214:
215: /**
216: * Display help text for an option.
217: * @param fp output file handle
218: * @param maxLeftCol largest argument display width
219: * @param opt option(s)
220: * @param translation_domain translation domain
221: */
222: static void singleOptionHelp(FILE * fp, size_t maxLeftCol,
223: const struct poptOption * opt,
224: /*@null@*/ UNUSED(const char * translation_domain))
225: /*@globals fileSystem @*/
226: /*@modifies *fp, fileSystem @*/
227: {
228: size_t indentLength = maxLeftCol + 5;
229: size_t lineLength = 79 - indentLength;
230: const char * help = D_(translation_domain, opt->descrip);
231: const char * argDescrip = getArgDescrip(opt, translation_domain);
232: size_t helpLength;
233: char * defs = NULL;
234: char * left;
235: size_t lelen, limit;
236: size_t nb = maxLeftCol + 1;
237: int displaypad = 0;
238:
239: /* Make sure there's more than enough room in target buffer. */
240: if (opt->longName) nb += strlen(opt->longName);
241: if (argDescrip) nb += strlen(argDescrip);
242:
243: /*@-boundswrite@*/
244: left = malloc(nb);
245: if (left == NULL) return; /* XXX can't happen */
246: left[0] = '\0';
247: left[maxLeftCol] = '\0';
248:
249: if (opt->longName && opt->shortName)
250: snprintf(left, nb, "-%c, %s%s", opt->shortName,
251: ((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"),
252: opt->longName);
253: else if (opt->shortName != '\0')
254: snprintf(left, nb, "-%c", opt->shortName);
255: else if (opt->longName)
256: snprintf(left, nb, "%s%s",
257: ((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"),
258: opt->longName);
259: if (!*left) goto out;
260:
261: if (argDescrip) {
262: char * le = left + strlen(left);
263:
264: if (opt->argInfo & POPT_ARGFLAG_OPTIONAL)
265: *le++ = '[';
266:
267: /* Choose type of output */
268: /*@-branchstate@*/
269: if (opt->argInfo & POPT_ARGFLAG_SHOW_DEFAULT) {
270: defs = singleOptionDefaultValue(lineLength, opt, translation_domain);
271: if (defs) {
272: size_t bufsize = (help ? strlen(help) : 0) + sizeof " " + strlen(defs);
273: char * t = malloc(bufsize);
274: if (t) {
275: snprintf(t, bufsize, "%s %s", help ? help : "", defs);
276: defs = _free(defs);
277: }
278: defs = t;
279: }
280: }
281: /*@=branchstate@*/
282:
283: if (opt->argDescrip == NULL) {
284: switch (opt->argInfo & POPT_ARG_MASK) {
285: case POPT_ARG_NONE:
286: break;
287: case POPT_ARG_VAL:
288: #ifdef NOTNOW /* XXX pug ugly nerdy output */
289: { long aLong = opt->val;
290: int ops = (opt->argInfo & POPT_ARGFLAG_LOGICALOPS);
291: int negate = (opt->argInfo & POPT_ARGFLAG_NOT);
292:
293: /* Don't bother displaying typical values */
294: if (!ops && (aLong == 0L || aLong == 1L || aLong == -1L))
295: break;
296: *le++ = '[';
297: switch (ops) {
298: case POPT_ARGFLAG_OR:
299: *le++ = '|';
300: /*@innerbreak@*/ break;
301: case POPT_ARGFLAG_AND:
302: *le++ = '&';
303: /*@innerbreak@*/ break;
304: case POPT_ARGFLAG_XOR:
305: *le++ = '^';
306: /*@innerbreak@*/ break;
307: default:
308: /*@innerbreak@*/ break;
309: }
310: *le++ = (opt->longName != NULL ? '=' : ' ');
311: if (negate) *le++ = '~';
312: /*@-formatconst@*/
313: limit = nb - (le - left);
314: lelen = snprintf(le, limit, (ops ? "0x%lx" : "%ld"), aLong);
315: le += lelen >= limit ? limit - 1 : lelen;
316: /*@=formatconst@*/
317: *le++ = ']';
318: }
319: #endif
320: break;
321: case POPT_ARG_INT:
322: case POPT_ARG_LONG:
323: case POPT_ARG_FLOAT:
324: case POPT_ARG_DOUBLE:
325: case POPT_ARG_STRING:
326: *le++ = (opt->longName != NULL ? '=' : ' ');
327: limit = nb - (le - left);
328: lelen = strlcpy(le, argDescrip, limit);
329: le += lelen >= limit ? limit - 1 : lelen;
330: break;
331: default:
332: break;
333: }
334: } else {
335:
336: *le++ = '=';
337: limit = nb - (le - left);
338: lelen = strlcpy(le, argDescrip, limit);
339: if (lelen >= limit)
340: lelen = limit - 1;
341: le += lelen;
342:
343: #ifdef POPT_WCHAR_HACK
344: { const char * scopy = argDescrip;
345: mbstate_t t;
346: size_t n;
347:
348: memset ((void *)&t, '\0', sizeof (t)); /* In initial state. */
349: /* Determine number of characters. */
350: n = mbsrtowcs (NULL, &scopy, strlen(scopy), &t);
351:
352: displaypad = (int) (lelen-n);
353: }
354: #endif
355: }
356: if (opt->argInfo & POPT_ARGFLAG_OPTIONAL)
357: *le++ = ']';
358: *le = '\0';
359: }
360: /*@=boundswrite@*/
361:
362: if (help)
363: fprintf(fp," %-*s ", (int)maxLeftCol+displaypad, left);
364: else {
365: fprintf(fp," %s\n", left);
366: goto out;
367: }
368:
369: left = _free(left);
370: /*@-branchstate@*/
371: if (defs) {
372: help = defs;
373: defs = NULL;
374: }
375: /*@=branchstate@*/
376:
377: helpLength = strlen(help);
378: /*@-boundsread@*/
379: while (helpLength > lineLength) {
380: const char * ch;
381: char format[16];
382:
383: ch = help + lineLength - 1;
384: while (ch > help && !isSpace(ch)) ch--;
385: if (ch == help) break; /* give up */
386: while (ch > (help + 1) && isSpace(ch)) ch--;
387: ch++;
388:
389: snprintf(format, sizeof format, "%%.%ds\n%%%ds", (int) (ch - help), (int) indentLength);
390: /*@-formatconst@*/
391: fprintf(fp, format, help, " ");
392: /*@=formatconst@*/
393: help = ch;
394: while (isSpace(help) && *help) help++;
395: helpLength = strlen(help);
396: }
397: /*@=boundsread@*/
398:
399: if (helpLength) fprintf(fp, "%s\n", help);
400:
401: out:
402: /*@-dependenttrans@*/
403: defs = _free(defs);
404: /*@=dependenttrans@*/
405: left = _free(left);
406: }
407:
408: /**
409: * Find display width for longest argument string.
410: * @param opt option(s)
411: * @param translation_domain translation domain
412: * @return display width
413: */
414: static size_t maxArgWidth(const struct poptOption * opt,
415: /*@null@*/ UNUSED(const char * translation_domain))
416: /*@*/
417: {
418: size_t max = 0;
419: size_t len = 0;
420: const char * s;
421:
422: if (opt != NULL)
423: while (opt->longName || opt->shortName || opt->arg) {
424: if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
425: if (opt->arg) /* XXX program error */
426: len = maxArgWidth(opt->arg, translation_domain);
427: if (len > max) max = len;
428: } else if (!(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN)) {
429: len = sizeof(" ")-1;
430: if (opt->shortName != '\0') len += sizeof("-X")-1;
431: if (opt->shortName != '\0' && opt->longName) len += sizeof(", ")-1;
432: if (opt->longName) {
433: len += ((opt->argInfo & POPT_ARGFLAG_ONEDASH)
434: ? sizeof("-")-1 : sizeof("--")-1);
435: len += strlen(opt->longName);
436: }
437:
438: s = getArgDescrip(opt, translation_domain);
439:
440: #ifdef POPT_WCHAR_HACK
441: /* XXX Calculate no. of display characters. */
442: if (s) {
443: const char * scopy = s;
444: mbstate_t t;
445: size_t n;
446:
447: /*@-boundswrite@*/
448: memset ((void *)&t, '\0', sizeof (t)); /* In initial state. */
449: /*@=boundswrite@*/
450: /* Determine number of characters. */
451: n = mbsrtowcs (NULL, &scopy, strlen(scopy), &t);
452: len += sizeof("=")-1 + n;
453: }
454: #else
455: if (s)
456: len += sizeof("=")-1 + strlen(s);
457: #endif
458:
459: if (opt->argInfo & POPT_ARGFLAG_OPTIONAL) len += sizeof("[]")-1;
460: if (len > max) max = len;
461: }
462:
463: opt++;
464: }
465:
466: return max;
467: }
468:
469: /**
470: * Display popt alias and exec help.
471: * @param fp output file handle
472: * @param items alias/exec array
473: * @param nitems no. of alias/exec entries
474: * @param left largest argument display width
475: * @param translation_domain translation domain
476: */
477: static void itemHelp(FILE * fp,
478: /*@null@*/ poptItem items, int nitems, size_t left,
479: /*@null@*/ UNUSED(const char * translation_domain))
480: /*@globals fileSystem @*/
481: /*@modifies *fp, fileSystem @*/
482: {
483: poptItem item;
484: int i;
485:
486: if (items != NULL)
487: for (i = 0, item = items; i < nitems; i++, item++) {
488: const struct poptOption * opt;
489: opt = &item->option;
490: if ((opt->longName || opt->shortName) &&
491: !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN))
492: singleOptionHelp(fp, left, opt, translation_domain);
493: }
494: }
495:
496: /**
497: * Display help text for a table of options.
498: * @param con context
499: * @param fp output file handle
500: * @param table option(s)
501: * @param left largest argument display width
502: * @param translation_domain translation domain
503: */
504: static void singleTableHelp(poptContext con, FILE * fp,
505: /*@null@*/ const struct poptOption * table, size_t left,
506: /*@null@*/ UNUSED(const char * translation_domain))
507: /*@globals fileSystem @*/
508: /*@modifies *fp, fileSystem @*/
509: {
510: const struct poptOption * opt;
511: const char *sub_transdom;
512:
513: if (table == poptAliasOptions) {
514: itemHelp(fp, con->aliases, con->numAliases, left, NULL);
515: itemHelp(fp, con->execs, con->numExecs, left, NULL);
516: return;
517: }
518:
519: if (table != NULL)
520: for (opt = table; (opt->longName || opt->shortName || opt->arg); opt++) {
521: if ((opt->longName || opt->shortName) &&
522: !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN))
523: singleOptionHelp(fp, left, opt, translation_domain);
524: }
525:
526: if (table != NULL)
527: for (opt = table; (opt->longName || opt->shortName || opt->arg); opt++) {
528: if ((opt->argInfo & POPT_ARG_MASK) != POPT_ARG_INCLUDE_TABLE)
529: continue;
530: sub_transdom = getTableTranslationDomain(opt->arg);
531: if (sub_transdom == NULL)
532: sub_transdom = translation_domain;
533:
534: if (opt->descrip)
535: fprintf(fp, "\n%s\n", D_(sub_transdom, opt->descrip));
536:
537: singleTableHelp(con, fp, opt->arg, left, sub_transdom);
538: }
539: }
540:
541: /**
542: * @param con context
543: * @param fp output file handle
544: */
545: static int showHelpIntro(poptContext con, FILE * fp)
546: /*@globals fileSystem @*/
547: /*@modifies *fp, fileSystem @*/
548: {
549: int len = 6;
550: const char * fn;
551:
552: fprintf(fp, POPT_("Usage:"));
553: if (!(con->flags & POPT_CONTEXT_KEEP_FIRST)) {
554: /*@-boundsread@*/
555: /*@-nullderef -type@*/ /* LCL: wazzup? */
556: fn = con->optionStack->argv[0];
557: /*@=nullderef =type@*/
558: /*@=boundsread@*/
559: if (fn == NULL) return len;
560: if (strchr(fn, '/')) fn = strrchr(fn, '/') + 1;
561: fprintf(fp, " %s", fn);
562: len += strlen(fn) + 1;
563: }
564:
565: return len;
566: }
567:
568: void poptPrintHelp(poptContext con, FILE * fp, /*@unused@*/ UNUSED(int flags))
569: {
570: size_t leftColWidth;
571:
572: (void) showHelpIntro(con, fp);
573: if (con->otherHelp)
574: fprintf(fp, " %s\n", con->otherHelp);
575: else
576: fprintf(fp, " %s\n", POPT_("[OPTION...]"));
577:
578: leftColWidth = maxArgWidth(con->options, NULL);
579: singleTableHelp(con, fp, con->options, leftColWidth, NULL);
580: }
581:
582: /**
583: * Display usage text for an option.
584: * @param fp output file handle
585: * @param cursor current display position
586: * @param opt option(s)
587: * @param translation_domain translation domain
588: */
589: static size_t singleOptionUsage(FILE * fp, size_t cursor,
590: const struct poptOption * opt,
591: /*@null@*/ const char *translation_domain)
592: /*@globals fileSystem @*/
593: /*@modifies *fp, fileSystem @*/
594: {
595: size_t len = 4;
596: char shortStr[2] = { '\0', '\0' };
597: const char * item = shortStr;
598: const char * argDescrip = getArgDescrip(opt, translation_domain);
599:
600: if (opt->shortName != '\0' && opt->longName != NULL) {
601: len += 2;
602: if (!(opt->argInfo & POPT_ARGFLAG_ONEDASH)) len++;
603: len += strlen(opt->longName);
604: } else if (opt->shortName != '\0') {
605: len++;
606: shortStr[0] = opt->shortName;
607: shortStr[1] = '\0';
608: } else if (opt->longName) {
609: len += strlen(opt->longName);
610: if (!(opt->argInfo & POPT_ARGFLAG_ONEDASH)) len++;
611: item = opt->longName;
612: }
613:
614: if (len == 4) return cursor;
615:
616: #ifdef POPT_WCHAR_HACK
617: /* XXX Calculate no. of display characters. */
618: if (argDescrip) {
619: const char * scopy = argDescrip;
620: mbstate_t t;
621: size_t n;
622:
623: /*@-boundswrite@*/
624: memset ((void *)&t, '\0', sizeof (t)); /* In initial state. */
625: /*@=boundswrite@*/
626: /* Determine number of characters. */
627: n = mbsrtowcs (NULL, &scopy, strlen(scopy), &t);
628: len += sizeof("=")-1 + n;
629: }
630: #else
631: if (argDescrip)
632: len += sizeof("=")-1 + strlen(argDescrip);
633: #endif
634:
635: if ((cursor + len) > 79) {
636: fprintf(fp, "\n ");
637: cursor = 7;
638: }
639:
640: if (opt->longName && opt->shortName) {
641: fprintf(fp, " [-%c|-%s%s%s%s]",
642: opt->shortName, ((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "" : "-"),
643: opt->longName,
644: (argDescrip ? " " : ""),
645: (argDescrip ? argDescrip : ""));
646: } else {
647: fprintf(fp, " [-%s%s%s%s]",
648: ((opt->shortName || (opt->argInfo & POPT_ARGFLAG_ONEDASH)) ? "" : "-"),
649: item,
650: (argDescrip ? (opt->shortName != '\0' ? " " : "=") : ""),
651: (argDescrip ? argDescrip : ""));
652: }
653:
654: return cursor + len + 1;
655: }
656:
657: /**
658: * Display popt alias and exec usage.
659: * @param fp output file handle
660: * @param cursor current display position
661: * @param item alias/exec array
662: * @param nitems no. of ara/exec entries
663: * @param translation_domain translation domain
664: */
665: static size_t itemUsage(FILE * fp, size_t cursor,
666: /*@null@*/ poptItem item, int nitems,
667: /*@null@*/ UNUSED(const char * translation_domain))
668: /*@globals fileSystem @*/
669: /*@modifies *fp, fileSystem @*/
670: {
671: int i;
672:
673: /*@-branchstate@*/ /* FIX: W2DO? */
674: if (item != NULL)
675: for (i = 0; i < nitems; i++, item++) {
676: const struct poptOption * opt;
677: opt = &item->option;
678: if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INTL_DOMAIN) {
679: translation_domain = (const char *)opt->arg;
680: } else if ((opt->longName || opt->shortName) &&
681: !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN)) {
682: cursor = singleOptionUsage(fp, cursor, opt, translation_domain);
683: }
684: }
685: /*@=branchstate@*/
686:
687: return cursor;
688: }
689:
690: /**
691: * Keep track of option tables already processed.
692: */
693: typedef struct poptDone_s {
694: int nopts;
695: int maxopts;
696: const void ** opts;
697: } * poptDone;
698:
699: /**
700: * Display usage text for a table of options.
701: * @param con context
702: * @param fp output file handle
703: * @param cursor current display position
704: * @param opt option(s)
705: * @param translation_domain translation domain
706: * @param done tables already processed
707: * @return
708: */
709: static size_t singleTableUsage(poptContext con, FILE * fp, size_t cursor,
710: /*@null@*/ const struct poptOption * opt,
711: /*@null@*/ UNUSED(const char * translation_domain),
712: /*@null@*/ poptDone done)
713: /*@globals fileSystem @*/
714: /*@modifies *fp, done, fileSystem @*/
715: {
716: /*@-branchstate@*/ /* FIX: W2DO? */
717: if (opt != NULL)
718: for (; (opt->longName || opt->shortName || opt->arg) ; opt++) {
719: if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INTL_DOMAIN) {
720: translation_domain = (const char *)opt->arg;
721: } else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE) {
722: if (done) {
723: int i = 0;
724: for (i = 0; i < done->nopts; i++) {
725: /*@-boundsread@*/
726: const void * that = done->opts[i];
727: /*@=boundsread@*/
728: if (that == NULL || that != opt->arg)
729: /*@innercontinue@*/ continue;
730: /*@innerbreak@*/ break;
731: }
732: /* Skip if this table has already been processed. */
733: if (opt->arg == NULL || i < done->nopts)
734: continue;
735: /*@-boundswrite@*/
736: if (done->nopts < done->maxopts)
737: done->opts[done->nopts++] = (const void *) opt->arg;
738: /*@=boundswrite@*/
739: }
740: cursor = singleTableUsage(con, fp, cursor, opt->arg,
741: translation_domain, done);
742: } else if ((opt->longName || opt->shortName) &&
743: !(opt->argInfo & POPT_ARGFLAG_DOC_HIDDEN)) {
744: cursor = singleOptionUsage(fp, cursor, opt, translation_domain);
745: }
746: }
747: /*@=branchstate@*/
748:
749: return cursor;
750: }
751:
752: /**
753: * Return concatenated short options for display.
754: * @todo Sub-tables should be recursed.
755: * @param opt option(s)
756: * @param fp output file handle
757: * @retval str concatenation of short options
758: * @return length of display string
759: */
760: static int showShortOptions(const struct poptOption * opt, FILE * fp,
761: /*@null@*/ char * str)
762: /*@globals fileSystem @*/
763: /*@modifies *str, *fp, fileSystem @*/
764: /*@requires maxRead(str) >= 0 @*/
765: {
766: /* bufsize larger then the ascii set, lazy alloca on top level call. */
767: char * s = (str != NULL ? str : memset(alloca(300), 0, 300));
768: int len = 0;
769:
770: if (s == NULL)
771: return 0;
772:
773: /*@-boundswrite@*/
774: if (opt != NULL)
775: for (; (opt->longName || opt->shortName || opt->arg); opt++) {
776: if (opt->shortName && !(opt->argInfo & POPT_ARG_MASK))
777: s[strlen(s)] = opt->shortName;
778: else if ((opt->argInfo & POPT_ARG_MASK) == POPT_ARG_INCLUDE_TABLE)
779: if (opt->arg) /* XXX program error */
780: len = showShortOptions(opt->arg, fp, s);
781: }
782: /*@=boundswrite@*/
783:
784: /* On return to top level, print the short options, return print length. */
785: if (s == str && *s != '\0') {
786: fprintf(fp, " [-%s]", s);
787: len = strlen(s) + sizeof(" [-]")-1;
788: }
789: return len;
790: }
791:
792: void poptPrintUsage(poptContext con, FILE * fp, /*@unused@*/ UNUSED(int flags))
793: {
794: poptDone done = memset(alloca(sizeof(*done)), 0, sizeof(*done));
795: size_t cursor;
796:
797: done->nopts = 0;
798: done->maxopts = 64;
799: cursor = done->maxopts * sizeof(*done->opts);
800: /*@-boundswrite@*/
801: done->opts = memset(alloca(cursor), 0, cursor);
802: /*@-keeptrans@*/
803: done->opts[done->nopts++] = (const void *) con->options;
804: /*@=keeptrans@*/
805: /*@=boundswrite@*/
806:
807: cursor = showHelpIntro(con, fp);
808: cursor += showShortOptions(con->options, fp, NULL);
809: cursor = singleTableUsage(con, fp, cursor, con->options, NULL, done);
810: cursor = itemUsage(fp, cursor, con->aliases, con->numAliases, NULL);
811: cursor = itemUsage(fp, cursor, con->execs, con->numExecs, NULL);
812:
813: if (con->otherHelp) {
814: cursor += strlen(con->otherHelp) + 1;
815: if (cursor > 79) fprintf(fp, "\n ");
816: fprintf(fp, " %s", con->otherHelp);
817: }
818:
819: fprintf(fp, "\n");
820: }
821:
822: void poptSetOtherOptionHelp(poptContext con, const char * text)
823: {
824: con->otherHelp = _free(con->otherHelp);
825: con->otherHelp = xstrdup(text);
826: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to popthelp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync / popt