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_USE_TIOCGWINSZ
14 #ifdef POPT_USE_TIOCGWINSZ
15 #include <sys/ioctl.h>
16 #endif
17 
18 #define	POPT_WCHAR_HACK
19 #ifdef 	POPT_WCHAR_HACK
20 #include <wchar.h>			/* for mbsrtowcs */
21 /*@access mbstate_t @*/
22 #endif
23 #include "poptint.h"
24 
25 /*@access poptContext@*/
26 
27 /**
28  * Display arguments.
29  * @param con		context
30  * @param foo		(unused)
31  * @param key		option(s)
32  * @param arg		(unused)
33  * @param data		(unused)
34  */
35 /*@exits@*/
displayArgs(poptContext con,UNUSED (enum poptCallbackReason foo),struct poptOption * key,UNUSED (const char * arg),UNUSED (void * data))36 static void displayArgs(poptContext con,
37 		/*@unused@*/ UNUSED(enum poptCallbackReason foo),
38 		struct poptOption * key,
39 		/*@unused@*/ UNUSED(const char * arg),
40 		/*@unused@*/ UNUSED(void * data))
41 	/*@globals fileSystem@*/
42 	/*@modifies fileSystem@*/
43 {
44     if (key->shortName == '?')
45 	poptPrintHelp(con, stdout, 0);
46     else
47 	poptPrintUsage(con, stdout, 0);
48 
49 #if !defined(__LCLINT__)	/* XXX keep both splint & valgrind happy */
50     con = poptFreeContext(con);
51 #endif
52     exit(0);
53 }
54 
55 #ifdef	NOTYET
56 /*@unchecked@*/
57 static int show_option_defaults = 0;
58 #endif
59 
60 /**
61  * Empty table marker to enable displaying popt alias/exec options.
62  */
63 /*@observer@*/ /*@unchecked@*/
64 struct poptOption poptAliasOptions[] = {
65     POPT_TABLEEND
66 };
67 
68 /**
69  * Auto help table options.
70  */
71 /*@-castfcnptr@*/
72 /*@observer@*/ /*@unchecked@*/
73 struct poptOption poptHelpOptions[] = {
74   { NULL, '\0', POPT_ARG_CALLBACK, (void *)displayArgs, 0, NULL, NULL },
75   { "help", '?', 0, NULL, (int)'?', N_("Show this help message"), NULL },
76   { "usage", '\0', 0, NULL, (int)'u', N_("Display brief usage message"), NULL },
77     POPT_TABLEEND
78 } ;
79 
80 /*@observer@*/ /*@unchecked@*/
81 static struct poptOption poptHelpOptions2[] = {
82 /*@-readonlytrans@*/
83   { NULL, '\0', POPT_ARG_INTL_DOMAIN, PACKAGE, 0, NULL, NULL},
84 /*@=readonlytrans@*/
85   { NULL, '\0', POPT_ARG_CALLBACK, (void *)displayArgs, 0, NULL, NULL },
86   { "help", '?', 0, NULL, (int)'?', N_("Show this help message"), NULL },
87   { "usage", '\0', 0, NULL, (int)'u', N_("Display brief usage message"), NULL },
88 #ifdef	NOTYET
89   { "defaults", '\0', POPT_ARG_NONE, &show_option_defaults, 0,
90 	N_("Display option defaults in message"), NULL },
91 #endif
92   { "", '\0',	0, NULL, 0, N_("Terminate options"), NULL },
93     POPT_TABLEEND
94 } ;
95 
96 /*@observer@*/ /*@unchecked@*/
97 struct poptOption * poptHelpOptionsI18N = poptHelpOptions2;
98 /*@=castfcnptr@*/
99 
100 #define        _POPTHELP_MAXLINE       ((size_t)79)
101 
102 typedef struct columns_s {
103     size_t cur;
104     size_t max;
105 } * columns_t;
106 
107 /**
108  * Return no. of columns in output window.
109  * @param fp           FILE
110  * @return             no. of columns
111  */
maxColumnWidth(FILE * fp)112 static size_t maxColumnWidth(FILE *fp)
113 	/*@*/
114 {
115     size_t maxcols = _POPTHELP_MAXLINE;
116 #if defined(TIOCGWINSZ)
117     struct winsize ws;
118     int fdno = fileno(fp ? fp : stdout);
119 
120     memset(&ws, 0, sizeof(ws));
121     if (fdno >= 0 && !ioctl(fdno, (unsigned long)TIOCGWINSZ, &ws)) {
122 	size_t ws_col = (size_t)ws.ws_col;
123 	if (ws_col > maxcols && ws_col < (size_t)256)
124 	    maxcols = ws_col - 1;
125     }
126 #endif
127     return maxcols;
128 }
129 
130 /**
131  * Determine number of display characters in a string.
132  * @param s		string
133  * @return		no. of display characters.
134  */
stringDisplayWidth(const char * s)135 static inline size_t stringDisplayWidth(const char *s)
136 	/*@*/
137 {
138     size_t n = strlen(s);
139 #ifdef	POPT_WCHAR_HACK
140     mbstate_t t;
141 
142     memset ((void *)&t, 0, sizeof (t));	/* In initial state.  */
143     /* Determine number of display characters.  */
144     n = mbsrtowcs (NULL, &s, n, &t);
145 #else
146     n = 0;
147     for (; *s; s = POPT_next_char(s))
148 	n++;
149 #endif
150 
151     return n;
152 }
153 
154 /**
155  * @param opt		option(s)
156  */
157 /*@observer@*/ /*@null@*/ static const char *
getTableTranslationDomain(const struct poptOption * opt)158 getTableTranslationDomain(/*@null@*/ const struct poptOption *opt)
159 	/*@*/
160 {
161     if (opt != NULL)
162     for (; opt->longName || opt->shortName || opt->arg; opt++) {
163 	if (opt->argInfo == POPT_ARG_INTL_DOMAIN)
164 	    return opt->arg;
165     }
166     return NULL;
167 }
168 
169 /**
170  * @param opt		option(s)
171  * @param translation_domain	translation domain
172  */
173 /*@observer@*/ /*@null@*/ static const char *
getArgDescrip(const struct poptOption * opt,const char * translation_domain)174 getArgDescrip(const struct poptOption * opt,
175 		/*@-paramuse@*/ /* FIX: i18n macros disabled with lclint */
176 		/*@null@*/ const char * translation_domain)
177 		/*@=paramuse@*/
178 	/*@*/
179 {
180     if (!poptArgType(opt)) return NULL;
181 
182     if (poptArgType(opt) == POPT_ARG_MAINCALL)
183 	return opt->argDescrip;
184     if (poptArgType(opt) == POPT_ARG_ARGV)
185 	return opt->argDescrip;
186 
187     if (opt->argDescrip) {
188 	/* Some strings need popt library, not application, i18n domain. */
189 	if (opt == (poptHelpOptions + 1)
190 	 || opt == (poptHelpOptions + 2)
191 	 || !strcmp(opt->argDescrip, N_("Help options:"))
192 	 || !strcmp(opt->argDescrip, N_("Options implemented via popt alias/exec:")))
193 	    return POPT_(opt->argDescrip);
194 
195 	/* Use the application i18n domain. */
196 	return D_(translation_domain, opt->argDescrip);
197     }
198 
199     switch (poptArgType(opt)) {
200     case POPT_ARG_NONE:		return POPT_("NONE");
201 #ifdef	DYING
202     case POPT_ARG_VAL:		return POPT_("VAL");
203 #else
204     case POPT_ARG_VAL:		return NULL;
205 #endif
206     case POPT_ARG_INT:		return POPT_("INT");
207     case POPT_ARG_SHORT:	return POPT_("SHORT");
208     case POPT_ARG_LONG:		return POPT_("LONG");
209     case POPT_ARG_LONGLONG:	return POPT_("LONGLONG");
210     case POPT_ARG_STRING:	return POPT_("STRING");
211     case POPT_ARG_FLOAT:	return POPT_("FLOAT");
212     case POPT_ARG_DOUBLE:	return POPT_("DOUBLE");
213     case POPT_ARG_MAINCALL:	return NULL;
214     case POPT_ARG_ARGV:		return NULL;
215     default:			return POPT_("ARG");
216     }
217 }
218 
219 /**
220  * Display default value for an option.
221  * @param lineLength	display positions remaining
222  * @param opt		option(s)
223  * @param translation_domain	translation domain
224  * @return
225  */
226 static /*@only@*/ /*@null@*/ char *
singleOptionDefaultValue(size_t lineLength,const struct poptOption * opt,const char * translation_domain)227 singleOptionDefaultValue(size_t lineLength,
228 		const struct poptOption * opt,
229 		/*@-paramuse@*/ /* FIX: i18n macros disabled with lclint */
230 		/*@null@*/ const char * translation_domain)
231 		/*@=paramuse@*/
232 	/*@*/
233 {
234     const char * defstr = D_(translation_domain, "default");
235     char * le = malloc(4*lineLength + 1);
236     char * l = le;
237 
238     if (le == NULL) return NULL;	/* XXX can't happen */
239     *le = '\0';
240     *le++ = '(';
241     le = stpcpy(le, defstr);
242     *le++ = ':';
243     *le++ = ' ';
244   if (opt->arg) {	/* XXX programmer error */
245     poptArg arg = { .ptr = opt->arg };
246     switch (poptArgType(opt)) {
247     case POPT_ARG_VAL:
248     case POPT_ARG_INT:
249 	le += sprintf(le, "%d", arg.intp[0]);
250 	break;
251     case POPT_ARG_SHORT:
252 	le += sprintf(le, "%hd", arg.shortp[0]);
253 	break;
254     case POPT_ARG_LONG:
255 	le += sprintf(le, "%ld", arg.longp[0]);
256 	break;
257     case POPT_ARG_LONGLONG:
258 	le += sprintf(le, "%lld", arg.longlongp[0]);
259 	break;
260     case POPT_ARG_FLOAT:
261     {	double aDouble = (double) arg.floatp[0];
262 	le += sprintf(le, "%g", aDouble);
263     }	break;
264     case POPT_ARG_DOUBLE:
265 	le += sprintf(le, "%g", arg.doublep[0]);
266 	break;
267     case POPT_ARG_MAINCALL:
268 	le += sprintf(le, "%p", opt->arg);
269 	break;
270     case POPT_ARG_ARGV:
271 	le += sprintf(le, "%p", opt->arg);
272 	break;
273     case POPT_ARG_STRING:
274     {	const char * s = arg.argv[0];
275 	if (s == NULL)
276 	    le = stpcpy(le, "null");
277 	else {
278 	    size_t limit = 4*lineLength - (le - l) - sizeof("\"\")");
279 	    size_t slen;
280 	    *le++ = '"';
281 	    strncpy(le, s, limit); le[limit] = '\0'; le += (slen = strlen(le));
282 	    if (slen == limit && s[limit])
283 		le[-1] = le[-2] = le[-3] = '.';
284 	    *le++ = '"';
285 	}
286     }	break;
287     case POPT_ARG_NONE:
288     default:
289 	l = _free(l);
290 	return NULL;
291 	/*@notreached@*/ break;
292     }
293   }
294     *le++ = ')';
295     *le = '\0';
296 
297     return l;
298 }
299 
300 /**
301  * Display help text for an option.
302  * @param fp		output file handle
303  * @param columns	output display width control
304  * @param opt		option(s)
305  * @param translation_domain	translation domain
306  */
singleOptionHelp(FILE * fp,columns_t columns,const struct poptOption * opt,const char * translation_domain)307 static void singleOptionHelp(FILE * fp, columns_t columns,
308 		const struct poptOption * opt,
309 		/*@null@*/ const char * translation_domain)
310 	/*@globals fileSystem @*/
311 	/*@modifies fp, fileSystem @*/
312 {
313     size_t maxLeftCol = columns->cur;
314     size_t indentLength = maxLeftCol + 5;
315     size_t lineLength = columns->max - indentLength;
316     const char * help = D_(translation_domain, opt->descrip);
317     const char * argDescrip = getArgDescrip(opt, translation_domain);
318     /* Display shortName iff printable non-space. */
319     int prtshort = (int)(isprint((int)opt->shortName) && opt->shortName != ' ');
320     size_t helpLength;
321     char * defs = NULL;
322     char * left;
323     size_t nb = maxLeftCol + 1;
324     int displaypad = 0;
325     int xx;
326 
327     /* Make sure there's more than enough room in target buffer. */
328     if (opt->longName)	nb += strlen(opt->longName);
329     if (F_ISSET(opt, TOGGLE)) nb += sizeof("[no]") - 1;
330     if (argDescrip)	nb += strlen(argDescrip);
331 
332     left = malloc(nb);
333     if (left == NULL) return;	/* XXX can't happen */
334     left[0] = '\0';
335     left[maxLeftCol] = '\0';
336 
337 #define	prtlong	(opt->longName != NULL)	/* XXX splint needs a clue */
338     if (!(prtshort || prtlong))
339 	goto out;
340     if (prtshort && prtlong) {
341 	char *dash = F_ISSET(opt, ONEDASH) ? "-" : "--";
342 	left[0] = '-';
343 	left[1] = opt->shortName;
344 	(void) stpcpy(stpcpy(stpcpy(left+2, ", "), dash), opt->longName);
345     } else if (prtshort) {
346 	left[0] = '-';
347 	left[1] = opt->shortName;
348 	left[2] = '\0';
349     } else if (prtlong) {
350 	/* XXX --long always padded for alignment with/without "-X, ". */
351 	char *dash = poptArgType(opt) == POPT_ARG_MAINCALL ? ""
352 		   : (F_ISSET(opt, ONEDASH) ? "-" : "--");
353 	const char *longName = opt->longName;
354 	const char *toggle;
355 	if (F_ISSET(opt, TOGGLE)) {
356 	    toggle = "[no]";
357 	    if (longName[0] == 'n' && longName[1] == 'o') {
358 		longName += sizeof("no") - 1;
359 		if (longName[0] == '-')
360 		    longName++;
361 	    }
362 	} else
363 	    toggle = "";
364 	(void) stpcpy(stpcpy(stpcpy(stpcpy(left, "    "), dash), toggle), longName);
365     }
366 #undef	prtlong
367 
368     if (argDescrip) {
369 	char * le = left + strlen(left);
370 
371 	if (F_ISSET(opt, OPTIONAL))
372 	    *le++ = '[';
373 
374 	/* Choose type of output */
375 	if (F_ISSET(opt, SHOW_DEFAULT)) {
376 	    defs = singleOptionDefaultValue(lineLength, opt, translation_domain);
377 	    if (defs) {
378 		char * t = malloc((help ? strlen(help) : 0) +
379 				strlen(defs) + sizeof(" "));
380 		if (t) {
381 		    char * te = t;
382 		    if (help)
383 			te = stpcpy(te, help);
384 		    *te++ = ' ';
385 		    strcpy(te, defs);
386 		    defs = _free(defs);
387 		    defs = t;
388 		}
389 	    }
390 	}
391 
392 	if (opt->argDescrip == NULL) {
393 	    switch (poptArgType(opt)) {
394 	    case POPT_ARG_NONE:
395 		break;
396 	    case POPT_ARG_VAL:
397 #ifdef	NOTNOW	/* XXX pug ugly nerdy output */
398 	    {	long aLong = opt->val;
399 		int ops = F_ISSET(opt, LOGICALOPS);
400 		int negate = F_ISSET(opt, NOT);
401 
402 		/* Don't bother displaying typical values */
403 		if (!ops && (aLong == 0L || aLong == 1L || aLong == -1L))
404 		    break;
405 		*le++ = '[';
406 		switch (ops) {
407 		case POPT_ARGFLAG_OR:
408 		    *le++ = '|';
409 		    /*@innerbreak@*/ break;
410 		case POPT_ARGFLAG_AND:
411 		    *le++ = '&';
412 		    /*@innerbreak@*/ break;
413 		case POPT_ARGFLAG_XOR:
414 		    *le++ = '^';
415 		    /*@innerbreak@*/ break;
416 		default:
417 		    /*@innerbreak@*/ break;
418 		}
419 		*le++ = (opt->longName != NULL ? '=' : ' ');
420 		if (negate) *le++ = '~';
421 		/*@-formatconst@*/
422 		le += sprintf(le, (ops ? "0x%lx" : "%ld"), aLong);
423 		/*@=formatconst@*/
424 		*le++ = ']';
425 	    }
426 #endif
427 		break;
428 	    case POPT_ARG_INT:
429 	    case POPT_ARG_SHORT:
430 	    case POPT_ARG_LONG:
431 	    case POPT_ARG_LONGLONG:
432 	    case POPT_ARG_FLOAT:
433 	    case POPT_ARG_DOUBLE:
434 	    case POPT_ARG_STRING:
435 		*le++ = (opt->longName != NULL ? '=' : ' ');
436 		le = stpcpy(le, argDescrip);
437 		break;
438 	    default:
439 		break;
440 	    }
441 	} else {
442 	    char *leo;
443 
444 	    /* XXX argDescrip[0] determines "--foo=bar" or "--foo bar". */
445 	    if (!strchr(" =(", argDescrip[0]))
446 		*le++ = ((poptArgType(opt) == POPT_ARG_MAINCALL) ? ' ' :
447 			 (poptArgType(opt) == POPT_ARG_ARGV) ? ' ' : '=');
448 	    le = stpcpy(leo = le, argDescrip);
449 
450 	    /* Adjust for (possible) wide characters. */
451 	    displaypad = (int)((le - leo) - stringDisplayWidth(argDescrip));
452 	}
453 	if (F_ISSET(opt, OPTIONAL))
454 	    *le++ = ']';
455 	*le = '\0';
456     }
457 
458     if (help)
459 	xx = POPT_fprintf(fp,"  %-*s   ", (int)(maxLeftCol+displaypad), left);
460     else {
461 	xx = POPT_fprintf(fp,"  %s\n", left);
462 	goto out;
463     }
464 
465     left = _free(left);
466     if (defs)
467 	help = defs;
468 
469     helpLength = strlen(help);
470     while (helpLength > lineLength) {
471 	const char * ch;
472 	char format[16];
473 
474 	ch = help + lineLength - 1;
475 	while (ch > help && !_isspaceptr(ch))
476 	    ch = POPT_prev_char(ch);
477 	if (ch == help) break;		/* give up */
478 	while (ch > (help + 1) && _isspaceptr(ch))
479 	    ch = POPT_prev_char (ch);
480 	ch = POPT_next_char(ch);
481 
482 	/*
483 	 *  XXX strdup is necessary to add NUL terminator so that an unknown
484 	 *  no. of (possible) multi-byte characters can be displayed.
485 	 */
486 	{   char * fmthelp = xstrdup(help);
487 	    if (fmthelp) {
488 		fmthelp[ch - help] = '\0';
489 		sprintf(format, "%%s\n%%%ds", (int) indentLength);
490 		/*@-formatconst@*/
491 		xx = POPT_fprintf(fp, format, fmthelp, " ");
492 		/*@=formatconst@*/
493 		free(fmthelp);
494 	    }
495 	}
496 
497 	help = ch;
498 	while (_isspaceptr(help) && *help)
499 	    help = POPT_next_char(help);
500 	helpLength = strlen(help);
501     }
502 
503     if (helpLength) fprintf(fp, "%s\n", help);
504     help = NULL;
505 
506 out:
507     /*@-dependenttrans@*/
508     defs = _free(defs);
509     /*@=dependenttrans@*/
510     left = _free(left);
511 }
512 
513 /**
514  * Find display width for longest argument string.
515  * @param opt		option(s)
516  * @param translation_domain	translation domain
517  * @return		display width
518  */
maxArgWidth(const struct poptOption * opt,const char * translation_domain)519 static size_t maxArgWidth(const struct poptOption * opt,
520 		       /*@null@*/ const char * translation_domain)
521 	/*@*/
522 {
523     size_t max = 0;
524     size_t len = 0;
525     const char * argDescrip;
526 
527     if (opt != NULL)
528     while (opt->longName || opt->shortName || opt->arg) {
529 	if (poptArgType(opt) == POPT_ARG_INCLUDE_TABLE) {
530 	    if (opt->arg)	/* XXX program error */
531 	        len = maxArgWidth(opt->arg, translation_domain);
532 	    if (len > max) max = len;
533 	} else if (!F_ISSET(opt, DOC_HIDDEN)) {
534 	    len = sizeof("  ")-1;
535 	    /* XXX --long always padded for alignment with/without "-X, ". */
536 	    len += sizeof("-X, ")-1;
537 	    if (opt->longName) {
538 		len += (F_ISSET(opt, ONEDASH) ? sizeof("-") : sizeof("--")) - 1;
539 		len += strlen(opt->longName);
540 	    }
541 
542 	    argDescrip = getArgDescrip(opt, translation_domain);
543 
544 	    if (argDescrip) {
545 
546 		/* XXX argDescrip[0] determines "--foo=bar" or "--foo bar". */
547 		if (!strchr(" =(", argDescrip[0])) len += sizeof("=")-1;
548 
549 		/* Adjust for (possible) wide characters. */
550 		len += stringDisplayWidth(argDescrip);
551 	    }
552 
553 	    if (F_ISSET(opt, OPTIONAL)) len += sizeof("[]")-1;
554 	    if (len > max) max = len;
555 	}
556 	opt++;
557     }
558 
559     return max;
560 }
561 
562 /**
563  * Display popt alias and exec help.
564  * @param fp		output file handle
565  * @param items		alias/exec array
566  * @param nitems	no. of alias/exec entries
567  * @param columns	output display width control
568  * @param translation_domain	translation domain
569  */
itemHelp(FILE * fp,poptItem items,int nitems,columns_t columns,const char * translation_domain)570 static void itemHelp(FILE * fp,
571 		/*@null@*/ poptItem items, int nitems,
572 		columns_t columns,
573 		/*@null@*/ const char * translation_domain)
574 	/*@globals fileSystem @*/
575 	/*@modifies fp, fileSystem @*/
576 {
577     poptItem item;
578     int i;
579 
580     if (items != NULL)
581     for (i = 0, item = items; i < nitems; i++, item++) {
582 	const struct poptOption * opt;
583 	opt = &item->option;
584 	if ((opt->longName || opt->shortName) && !F_ISSET(opt, DOC_HIDDEN))
585 	    singleOptionHelp(fp, columns, opt, translation_domain);
586     }
587 }
588 
589 /**
590  * Display help text for a table of options.
591  * @param con		context
592  * @param fp		output file handle
593  * @param table		option(s)
594  * @param columns	output display width control
595  * @param translation_domain	translation domain
596  */
singleTableHelp(poptContext con,FILE * fp,const struct poptOption * table,columns_t columns,const char * translation_domain)597 static void singleTableHelp(poptContext con, FILE * fp,
598 		/*@null@*/ const struct poptOption * table,
599 		columns_t columns,
600 		/*@null@*/ const char * translation_domain)
601 	/*@globals fileSystem @*/
602 	/*@modifies fp, columns->cur, fileSystem @*/
603 {
604     const struct poptOption * opt;
605     const char *sub_transdom;
606     int xx;
607 
608     if (table == poptAliasOptions) {
609 	itemHelp(fp, con->aliases, con->numAliases, columns, NULL);
610 	itemHelp(fp, con->execs, con->numExecs, columns, NULL);
611 	return;
612     }
613 
614     if (table != NULL)
615     for (opt = table; opt->longName || opt->shortName || opt->arg; opt++) {
616 	if ((opt->longName || opt->shortName) && !F_ISSET(opt, DOC_HIDDEN))
617 	    singleOptionHelp(fp, columns, opt, translation_domain);
618     }
619 
620     if (table != NULL)
621     for (opt = table; opt->longName || opt->shortName || opt->arg; opt++) {
622 	if (poptArgType(opt) != POPT_ARG_INCLUDE_TABLE)
623 	    continue;
624 	sub_transdom = getTableTranslationDomain(opt->arg);
625 	if (sub_transdom == NULL)
626 	    sub_transdom = translation_domain;
627 
628 	/* If no popt aliases/execs, skip poptAliasOption processing. */
629 	if (opt->arg == poptAliasOptions && !(con->numAliases || con->numExecs))
630 	    continue;
631 	if (opt->descrip)
632 	    xx = POPT_fprintf(fp, "\n%s\n", D_(sub_transdom, opt->descrip));
633 
634 	singleTableHelp(con, fp, opt->arg, columns, sub_transdom);
635     }
636 }
637 
638 /**
639  * @param con		context
640  * @param fp		output file handle
641  */
showHelpIntro(poptContext con,FILE * fp)642 static size_t showHelpIntro(poptContext con, FILE * fp)
643 	/*@globals fileSystem @*/
644 	/*@modifies fp, fileSystem @*/
645 {
646     size_t len = (size_t)6;
647     int xx;
648 
649     xx = POPT_fprintf(fp, POPT_("Usage:"));
650     if (!(con->flags & POPT_CONTEXT_KEEP_FIRST)) {
651 	struct optionStackEntry * os = con->optionStack;
652 	const char * fn = (os->argv ? os->argv[0] : NULL);
653 	if (fn == NULL) return len;
654 	if (strchr(fn, '/')) fn = strrchr(fn, '/') + 1;
655 	/* XXX POPT_fprintf not needed for argv[0] display. */
656 	fprintf(fp, " %s", fn);
657 	len += strlen(fn) + 1;
658     }
659 
660     return len;
661 }
662 
poptPrintHelp(poptContext con,FILE * fp,UNUSED (int flags))663 void poptPrintHelp(poptContext con, FILE * fp, /*@unused@*/ UNUSED(int flags))
664 {
665     columns_t columns = calloc((size_t)1, sizeof(*columns));
666     int xx;
667 
668     (void) showHelpIntro(con, fp);
669     if (con->otherHelp)
670 	xx = POPT_fprintf(fp, " %s\n", con->otherHelp);
671     else
672 	xx = POPT_fprintf(fp, " %s\n", POPT_("[OPTION...]"));
673 
674     if (columns) {
675 	columns->cur = maxArgWidth(con->options, NULL);
676 	columns->max = maxColumnWidth(fp);
677 	singleTableHelp(con, fp, con->options, columns, NULL);
678 	free(columns);
679     }
680 }
681 
682 /**
683  * Display usage text for an option.
684  * @param fp		output file handle
685  * @param columns	output display width control
686  * @param opt		option(s)
687  * @param translation_domain	translation domain
688  */
singleOptionUsage(FILE * fp,columns_t columns,const struct poptOption * opt,const char * translation_domain)689 static size_t singleOptionUsage(FILE * fp, columns_t columns,
690 		const struct poptOption * opt,
691 		/*@null@*/ const char *translation_domain)
692 	/*@globals fileSystem @*/
693 	/*@modifies fp, columns->cur, fileSystem @*/
694 {
695     size_t len = sizeof(" []")-1;
696     const char * argDescrip = getArgDescrip(opt, translation_domain);
697     /* Display shortName iff printable non-space. */
698     int prtshort = (int)(isprint((int)opt->shortName) && opt->shortName != ' ');
699 
700 #define	prtlong	(opt->longName != NULL)	/* XXX splint needs a clue */
701     if (!(prtshort || prtlong))
702 	return columns->cur;
703 
704     len = sizeof(" []")-1;
705     if (prtshort)
706 	len += sizeof("-c")-1;
707     if (prtlong) {
708 	if (prtshort) len += sizeof("|")-1;
709 	len += (F_ISSET(opt, ONEDASH) ? sizeof("-") : sizeof("--")) - 1;
710 	len += strlen(opt->longName);
711     }
712 
713     if (argDescrip) {
714 
715 	/* XXX argDescrip[0] determines "--foo=bar" or "--foo bar". */
716 	if (!strchr(" =(", argDescrip[0])) len += sizeof("=")-1;
717 
718 	/* Adjust for (possible) wide characters. */
719 	len += stringDisplayWidth(argDescrip);
720     }
721 
722     if ((columns->cur + len) > columns->max) {
723 	fprintf(fp, "\n       ");
724 	columns->cur = (size_t)7;
725     }
726 
727     fprintf(fp, " [");
728     if (prtshort)
729 	fprintf(fp, "-%c", opt->shortName);
730     if (prtlong)
731 	fprintf(fp, "%s%s%s",
732 		(prtshort ? "|" : ""),
733 		(F_ISSET(opt, ONEDASH) ? "-" : "--"),
734 		opt->longName);
735 #undef	prtlong
736 
737     if (argDescrip) {
738 	/* XXX argDescrip[0] determines "--foo=bar" or "--foo bar". */
739 	if (!strchr(" =(", argDescrip[0])) fprintf(fp, "=");
740 	fprintf(fp, "%s", argDescrip);
741     }
742     fprintf(fp, "]");
743 
744     return columns->cur + len + 1;
745 }
746 
747 /**
748  * Display popt alias and exec usage.
749  * @param fp		output file handle
750  * @param columns	output display width control
751  * @param item		alias/exec array
752  * @param nitems	no. of ara/exec entries
753  * @param translation_domain	translation domain
754  */
itemUsage(FILE * fp,columns_t columns,poptItem item,int nitems,const char * translation_domain)755 static size_t itemUsage(FILE * fp, columns_t columns,
756 		/*@null@*/ poptItem item, int nitems,
757 		/*@null@*/ const char * translation_domain)
758 	/*@globals fileSystem @*/
759 	/*@modifies fp, columns->cur, fileSystem @*/
760 {
761     int i;
762 
763     if (item != NULL)
764     for (i = 0; i < nitems; i++, item++) {
765 	const struct poptOption * opt;
766 	opt = &item->option;
767         if (poptArgType(opt) == POPT_ARG_INTL_DOMAIN) {
768 	    translation_domain = (const char *)opt->arg;
769 	} else
770 	if ((opt->longName || opt->shortName) && !F_ISSET(opt, DOC_HIDDEN)) {
771 	    columns->cur = singleOptionUsage(fp, columns, opt, translation_domain);
772 	}
773     }
774 
775     return columns->cur;
776 }
777 
778 /**
779  * Keep track of option tables already processed.
780  */
781 typedef struct poptDone_s {
782     int nopts;
783     int maxopts;
784 /*@null@*/
785     const void ** opts;
786 } * poptDone;
787 
788 /**
789  * Display usage text for a table of options.
790  * @param con		context
791  * @param fp		output file handle
792  * @param columns	output display width control
793  * @param opt		option(s)
794  * @param translation_domain	translation domain
795  * @param done		tables already processed
796  * @return
797  */
singleTableUsage(poptContext con,FILE * fp,columns_t columns,const struct poptOption * opt,const char * translation_domain,poptDone done)798 static size_t singleTableUsage(poptContext con, FILE * fp, columns_t columns,
799 		/*@null@*/ const struct poptOption * opt,
800 		/*@null@*/ const char * translation_domain,
801 		/*@null@*/ poptDone done)
802 	/*@globals fileSystem @*/
803 	/*@modifies fp, columns->cur, done, fileSystem @*/
804 {
805     if (opt != NULL)
806     for (; (opt->longName || opt->shortName || opt->arg) ; opt++) {
807         if (poptArgType(opt) == POPT_ARG_INTL_DOMAIN) {
808 	    translation_domain = (const char *)opt->arg;
809 	} else
810 	if (poptArgType(opt) == POPT_ARG_INCLUDE_TABLE) {
811 	    if (done) {
812 		int i = 0;
813 		if (done->opts != NULL)
814 		for (i = 0; i < done->nopts; i++) {
815 		    const void * that = done->opts[i];
816 		    if (that == NULL || that != opt->arg)
817 			/*@innercontinue@*/ continue;
818 		    /*@innerbreak@*/ break;
819 		}
820 		/* Skip if this table has already been processed. */
821 		if (opt->arg == NULL || i < done->nopts)
822 		    continue;
823 		if (done->opts != NULL && done->nopts < done->maxopts)
824 		    done->opts[done->nopts++] = (const void *) opt->arg;
825 	    }
826 	    columns->cur = singleTableUsage(con, fp, columns, opt->arg,
827 			translation_domain, done);
828 	} else
829 	if ((opt->longName || opt->shortName) && !F_ISSET(opt, DOC_HIDDEN)) {
830 	    columns->cur = singleOptionUsage(fp, columns, opt, translation_domain);
831 	}
832     }
833 
834     return columns->cur;
835 }
836 
837 /**
838  * Return concatenated short options for display.
839  * @todo Sub-tables should be recursed.
840  * @param opt		option(s)
841  * @param fp		output file handle
842  * @retval str		concatenation of short options
843  * @return		length of display string
844  */
showShortOptions(const struct poptOption * opt,FILE * fp,char * str)845 static size_t showShortOptions(const struct poptOption * opt, FILE * fp,
846 		/*@null@*/ char * str)
847 	/*@globals fileSystem @*/
848 	/*@modifies str, *fp, fileSystem @*/
849 	/*@requires maxRead(str) >= 0 @*/
850 {
851     /* bufsize larger then the ascii set, lazy allocation on top level call. */
852     size_t nb = (size_t)300;
853     char * s = (str != NULL ? str : calloc((size_t)1, nb));
854     size_t len = (size_t)0;
855 
856     if (s == NULL)
857 	return 0;
858 
859     if (opt != NULL)
860     for (; (opt->longName || opt->shortName || opt->arg); opt++) {
861 	if (!F_ISSET(opt, DOC_HIDDEN) && opt->shortName && !poptArgType(opt))
862 	{
863 	    /* Display shortName iff unique printable non-space. */
864 	    if (!strchr(s, opt->shortName) && isprint((int)opt->shortName)
865 	     && opt->shortName != ' ')
866 		s[strlen(s)] = opt->shortName;
867 	} else if (poptArgType(opt) == POPT_ARG_INCLUDE_TABLE)
868 	    if (opt->arg)	/* XXX program error */
869 		len = showShortOptions(opt->arg, fp, s);
870     }
871 
872     /* On return to top level, print the short options, return print length. */
873     if (s != str && *s != '\0') {
874 	fprintf(fp, " [-%s]", s);
875 	len = strlen(s) + sizeof(" [-]")-1;
876     }
877 /*@-temptrans@*/	/* LCL: local s, not str arg, is being freed. */
878     if (s != str)
879 	free(s);
880 /*@=temptrans@*/
881     return len;
882 }
883 
poptPrintUsage(poptContext con,FILE * fp,UNUSED (int flags))884 void poptPrintUsage(poptContext con, FILE * fp, /*@unused@*/ UNUSED(int flags))
885 {
886     columns_t columns = calloc((size_t)1, sizeof(*columns));
887     struct poptDone_s done_buf;
888     poptDone done = &done_buf;
889 
890     memset(done, 0, sizeof(*done));
891     done->nopts = 0;
892     done->maxopts = 64;
893   if (columns) {
894     columns->cur = done->maxopts * sizeof(*done->opts);
895     columns->max = maxColumnWidth(fp);
896     done->opts = calloc((size_t)1, columns->cur);
897     /*@-keeptrans@*/
898     if (done->opts != NULL)
899 	done->opts[done->nopts++] = (const void *) con->options;
900     /*@=keeptrans@*/
901 
902     columns->cur = showHelpIntro(con, fp);
903     columns->cur += showShortOptions(con->options, fp, NULL);
904     columns->cur = singleTableUsage(con, fp, columns, con->options, NULL, done);
905     columns->cur = itemUsage(fp, columns, con->aliases, con->numAliases, NULL);
906     columns->cur = itemUsage(fp, columns, con->execs, con->numExecs, NULL);
907 
908     if (con->otherHelp) {
909 	columns->cur += strlen(con->otherHelp) + 1;
910 	if (columns->cur > columns->max) fprintf(fp, "\n       ");
911 	fprintf(fp, " %s", con->otherHelp);
912     }
913 
914     fprintf(fp, "\n");
915     if (done->opts != NULL)
916 	free(done->opts);
917     free(columns);
918   }
919 }
920 
poptSetOtherOptionHelp(poptContext con,const char * text)921 void poptSetOtherOptionHelp(poptContext con, const char * text)
922 {
923     con->otherHelp = _free(con->otherHelp);
924     con->otherHelp = xstrdup(text);
925 }
926