?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Honour HAVE_POPT*
[rsync/qnx.git] / popt / popthelp.c
blob6a009766de3ba5b09066955062fc2f57f7c4b3b5
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 }