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