1 /* Hierarchial argument parsing help output
2 Copyright (C) 1995-2005, 2007, 2009-2011 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Written by Miles Bader <miles@gnu.ai.mit.edu>.
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 # define _GNU_SOURCE 1
43 # define dgettext(domain, msgid) \
44 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
50 #include "argp-fmtstream.h"
51 #include "argp-namefrob.h"
54 # define SIZE_MAX ((size_t) -1)
57 /* User-selectable (using an environment variable) formatting parameters.
59 These may be specified in an environment variable called `ARGP_HELP_FMT',
60 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
61 Where VALn must be a positive integer. The list of variables is in the
62 UPARAM_NAMES vector, below. */
64 /* Default parameters. */
65 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
66 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
67 #define SHORT_OPT_COL 2 /* column in which short options start */
68 #define LONG_OPT_COL 6 /* column in which long options start */
69 #define DOC_OPT_COL 2 /* column in which doc options start */
70 #define OPT_DOC_COL 29 /* column in which option text starts */
71 #define HEADER_COL 1 /* column in which group headers are printed */
72 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
73 #define RMARGIN 79 /* right margin used for wrapping */
75 /* User-selectable (using an environment variable) formatting parameters.
76 They must all be of type `int' for the parsing code to work. */
79 /* If true, arguments for an option are shown with both short and long
80 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
81 If false, then if an option has both, the argument is only shown with
82 the long one, e.g., `-x, --longx=ARG', and a message indicating that
83 this really means both is printed below the options. */
86 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
87 been suppressed, an explanatory message should be printed. */
90 /* Various output columns. */
91 int short_opt_col; /* column in which short options start */
92 int long_opt_col; /* column in which long options start */
93 int doc_opt_col; /* column in which doc options start */
94 int opt_doc_col; /* column in which option text starts */
95 int header_col; /* column in which group headers are printed */
96 int usage_indent; /* indentation of wrapped usage lines */
97 int rmargin; /* right margin used for wrapping */
99 int valid; /* True when the values in here are valid. */
102 /* This is a global variable, as user options are only ever read once. */
103 static struct uparams uparams = {
104 DUP_ARGS, DUP_ARGS_NOTE,
105 SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,
106 USAGE_INDENT, RMARGIN,
110 /* A particular uparam, and what the user name is. */
113 const char *name; /* User name. */
114 int is_bool; /* Whether it's `boolean'. */
115 size_t uparams_offs; /* Location of the (int) field in UPARAMS. */
118 /* The name-field mappings we know about. */
119 static const struct uparam_name uparam_names[] =
121 { "dup-args", 1, offsetof (struct uparams, dup_args) },
122 { "dup-args-note", 1, offsetof (struct uparams, dup_args_note) },
123 { "short-opt-col", 0, offsetof (struct uparams, short_opt_col) },
124 { "long-opt-col", 0, offsetof (struct uparams, long_opt_col) },
125 { "doc-opt-col", 0, offsetof (struct uparams, doc_opt_col) },
126 { "opt-doc-col", 0, offsetof (struct uparams, opt_doc_col) },
127 { "header-col", 0, offsetof (struct uparams, header_col) },
128 { "usage-indent", 0, offsetof (struct uparams, usage_indent) },
129 { "rmargin", 0, offsetof (struct uparams, rmargin) },
134 validate_uparams (const struct argp_state *state, struct uparams *upptr)
136 const struct uparam_name *up;
138 for (up = uparam_names; up->name; up++)
141 || up->uparams_offs == offsetof (struct uparams, rmargin))
143 if (*(int *)((char *)upptr + up->uparams_offs) >= upptr->rmargin)
145 __argp_failure (state, 0, 0,
146 dgettext (state->root_argp->argp_domain,
148 ARGP_HELP_FMT: %s value is less than or equal to %s"),
149 "rmargin", up->name);
157 /* Read user options from the environment, and fill in UPARAMS appropiately. */
159 fill_in_uparams (const struct argp_state *state)
161 const char *var = getenv ("ARGP_HELP_FMT");
162 struct uparams new_params = uparams;
164 #define SKIPWS(p) do { while (isspace ((unsigned char) *p)) p++; } while (0);
173 if (isalpha ((unsigned char) *var))
176 const struct uparam_name *un;
177 int unspec = 0, val = 0;
178 const char *arg = var;
180 while (isalnum ((unsigned char) *arg) || *arg == '-' || *arg == '_')
186 if (*arg == '\0' || *arg == ',')
188 else if (*arg == '=')
196 if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')
205 else if (isdigit ((unsigned char) *arg))
208 while (isdigit ((unsigned char) *arg))
213 for (un = uparam_names; un->name; un++)
214 if (strlen (un->name) == var_len
215 && strncmp (var, un->name, var_len) == 0)
217 if (unspec && !un->is_bool)
218 __argp_failure (state, 0, 0,
219 dgettext (state->root_argp->argp_domain,
221 %.*s: ARGP_HELP_FMT parameter requires a value"),
224 __argp_failure (state, 0, 0,
225 dgettext (state->root_argp->argp_domain,
227 %.*s: ARGP_HELP_FMT parameter must be positive"),
230 *(int *)((char *)&new_params + un->uparams_offs) = val;
234 __argp_failure (state, 0, 0,
235 dgettext (state->root_argp->argp_domain, "\
236 %.*s: Unknown ARGP_HELP_FMT parameter"),
245 __argp_failure (state, 0, 0,
246 dgettext (state->root_argp->argp_domain,
247 "Garbage in ARGP_HELP_FMT: %s"), var);
251 validate_uparams (state, &new_params);
255 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
256 whether OPT is displayed or used in sorting, not option shadowing. */
257 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
259 /* Returns true if OPT is an alias for an earlier option. */
260 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
262 /* Returns true if OPT is a documentation-only entry. */
263 #define odoc(opt) ((opt)->flags & OPTION_DOC)
265 /* Returns true if OPT should not be translated */
266 #define onotrans(opt) ((opt)->flags & OPTION_NO_TRANS)
268 /* Returns true if OPT is the end-of-list marker for a list of options. */
269 #define oend(opt) __option_is_end (opt)
271 /* Returns true if OPT has a short option. */
272 #define oshort(opt) __option_is_short (opt)
275 The help format for a particular option is like:
277 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
279 Where ARG will be omitted if there's no argument, for this option, or
280 will be surrounded by "[" and "]" appropiately if the argument is
281 optional. The documentation string is word-wrapped appropiately, and if
282 the list of options is long enough, it will be started on a separate line.
283 If there are no short options for a given option, the first long option is
284 indented slighly in a way that's supposed to make most long options appear
285 to be in a separate column.
287 For example, the following output (from ps):
289 -p PID, --pid=PID List the process PID
290 --pgrp=PGRP List processes in the process group PGRP
291 -P, -x, --no-parent Include processes without parents
292 -Q, --all-fields Don't elide unusable fields (normally if there's
293 some reason ps can't print a field for any
294 process, it's removed from the output entirely)
295 -r, --reverse, --gratuitously-long-reverse-option
296 Reverse the order of any sort
297 --session[=SID] Add the processes from the session SID (which
298 defaults to the sid of the current process)
300 Here are some more options:
301 -f ZOT, --foonly=ZOT Glork a foonly
302 -z, --zaza Snit a zar
304 -?, --help Give this help list
305 --usage Give a short usage message
306 -V, --version Print program version
308 The struct argp_option array for the above could look like:
311 {"pid", 'p', "PID", 0, "List the process PID"},
312 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
313 {"no-parent", 'P', 0, 0, "Include processes without parents"},
314 {0, 'x', 0, OPTION_ALIAS},
315 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
316 " if there's some reason ps can't"
317 " print a field for any process, it's"
318 " removed from the output entirely)" },
319 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
320 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
321 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
322 "Add the processes from the session"
323 " SID (which defaults to the sid of"
324 " the current process)" },
326 {0,0,0,0, "Here are some more options:"},
327 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
328 {"zaza", 'z', 0, 0, "Snit a zar"},
333 Note that the last three options are automatically supplied by argp_parse,
334 unless you tell it not to with ARGP_NO_HELP.
338 /* Returns true if CH occurs between BEG and END. */
340 find_char (char ch, char *beg, char *end)
350 struct hol_cluster; /* fwd decl */
355 const struct argp_option *opt;
356 /* Number of options (including aliases). */
359 /* A pointers into the HOL's short_options field, to the first short option
360 letter for this entry. The order of the characters following this point
361 corresponds to the order of options pointed to by OPT, and there are at
362 most NUM. A short option recorded in an option following OPT is only
363 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
364 probably been shadowed by some other entry). */
367 /* Entries are sorted by their group first, in the order:
368 1, 2, ..., n, 0, -m, ..., -2, -1
369 and then alphabetically within each group. The default is 0. */
372 /* The cluster of options this entry belongs to, or 0 if none. */
373 struct hol_cluster *cluster;
375 /* The argp from which this option came. */
376 const struct argp *argp;
378 /* Position in the array */
382 /* A cluster of entries to reflect the argp tree structure. */
385 /* A descriptive header printed before options in this cluster. */
388 /* Used to order clusters within the same group with the same parent,
389 according to the order in which they occurred in the parent argp's child
393 /* How to sort this cluster with respect to options and other clusters at the
394 same depth (clusters always follow options in the same group). */
397 /* The cluster to which this cluster belongs, or 0 if it's at the base
399 struct hol_cluster *parent;
401 /* The argp from which this cluster is (eventually) derived. */
402 const struct argp *argp;
404 /* The distance this cluster is from the root. */
407 /* Clusters in a given hol are kept in a linked list, to make freeing them
409 struct hol_cluster *next;
412 /* A list of options for help. */
415 /* An array of hol_entry's. */
416 struct hol_entry *entries;
417 /* The number of entries in this hol. If this field is zero, the others
419 unsigned num_entries;
421 /* A string containing all short options in this HOL. Each entry contains
422 pointers into this string, so the order can't be messed with blindly. */
425 /* Clusters of entries in this hol. */
426 struct hol_cluster *clusters;
429 /* Create a struct hol from the options in ARGP. CLUSTER is the
430 hol_cluster in which these entries occur, or 0, if at the root. */
432 make_hol (const struct argp *argp, struct hol_cluster *cluster)
435 const struct argp_option *o;
436 const struct argp_option *opts = argp->options;
437 struct hol_entry *entry;
438 unsigned num_short_options = 0;
439 struct hol *hol = malloc (sizeof (struct hol));
443 hol->num_entries = 0;
450 /* The first option must not be an alias. */
451 assert (! oalias (opts));
453 /* Calculate the space needed. */
454 for (o = opts; ! oend (o); o++)
459 num_short_options++; /* This is an upper bound. */
462 hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);
463 hol->short_options = malloc (num_short_options + 1);
465 assert (hol->entries && hol->short_options);
466 if (SIZE_MAX <= UINT_MAX)
467 assert (hol->num_entries <= SIZE_MAX / sizeof (struct hol_entry));
469 /* Fill in the entries. */
470 so = hol->short_options;
471 for (o = opts, entry = hol->entries; ! oend (o); entry++)
475 entry->short_options = so;
476 entry->group = cur_group =
479 : ((!o->name && !o->key)
482 entry->cluster = cluster;
488 if (oshort (o) && ! find_char (o->key, hol->short_options, so))
489 /* O has a valid short option which hasn't already been used.*/
493 while (! oend (o) && oalias (o));
495 *so = '\0'; /* null terminated so we can find the length */
501 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
502 associated argp child list entry), INDEX, and PARENT, and return a pointer
503 to it. ARGP is the argp that this cluster results from. */
504 static struct hol_cluster *
505 hol_add_cluster (struct hol *hol, int group, const char *header, int index,
506 struct hol_cluster *parent, const struct argp *argp)
508 struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));
517 cl->depth = parent ? parent->depth + 1 : 0;
519 cl->next = hol->clusters;
525 /* Free HOL and any resources it uses. */
527 hol_free (struct hol *hol)
529 struct hol_cluster *cl = hol->clusters;
533 struct hol_cluster *next = cl->next;
538 if (hol->num_entries > 0)
541 free (hol->short_options);
548 hol_entry_short_iterate (const struct hol_entry *entry,
549 int (*func)(const struct argp_option *opt,
550 const struct argp_option *real,
551 const char *domain, void *cookie),
552 const char *domain, void *cookie)
556 const struct argp_option *opt, *real = entry->opt;
557 char *so = entry->short_options;
559 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
560 if (oshort (opt) && *so == opt->key)
565 val = (*func)(opt, real, domain, cookie);
574 __attribute__ ((always_inline))
576 hol_entry_long_iterate (const struct hol_entry *entry,
577 int (*func)(const struct argp_option *opt,
578 const struct argp_option *real,
579 const char *domain, void *cookie),
580 const char *domain, void *cookie)
584 const struct argp_option *opt, *real = entry->opt;
586 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
592 val = (*func)(opt, real, domain, cookie);
598 /* Iterator that returns true for the first short option. */
600 until_short (const struct argp_option *opt, const struct argp_option *real,
601 const char *domain, void *cookie)
603 return oshort (opt) ? opt->key : 0;
606 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
608 hol_entry_first_short (const struct hol_entry *entry)
610 return hol_entry_short_iterate (entry, until_short,
611 entry->argp->argp_domain, 0);
614 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
616 hol_entry_first_long (const struct hol_entry *entry)
618 const struct argp_option *opt;
620 for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
621 if (opt->name && ovisible (opt))
626 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
628 static struct hol_entry *
629 hol_find_entry (struct hol *hol, const char *name)
631 struct hol_entry *entry = hol->entries;
632 unsigned num_entries = hol->num_entries;
634 while (num_entries-- > 0)
636 const struct argp_option *opt = entry->opt;
637 unsigned num_opts = entry->num;
639 while (num_opts-- > 0)
640 if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
651 /* If an entry with the long option NAME occurs in HOL, set it's special
652 sort position to GROUP. */
654 hol_set_group (struct hol *hol, const char *name, int group)
656 struct hol_entry *entry = hol_find_entry (hol, name);
658 entry->group = group;
661 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
662 EQ is what to return if GROUP1 and GROUP2 are the same. */
664 group_cmp (int group1, int group2, int eq)
666 if (group1 == group2)
668 else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
669 return group1 - group2;
671 return group2 - group1;
674 /* Compare clusters CL1 & CL2 by the order that they should appear in
677 hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
679 /* If one cluster is deeper than the other, use its ancestor at the same
680 level, so that finding the common ancestor is straightforward.
682 clN->depth > 0 means that clN->parent != NULL (see hol_add_cluster) */
683 while (cl1->depth > cl2->depth)
685 while (cl2->depth > cl1->depth)
688 /* Now reduce both clusters to their ancestors at the point where both have
689 a common parent; these can be directly compared. */
690 while (cl1->parent != cl2->parent)
691 cl1 = cl1->parent, cl2 = cl2->parent;
693 return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
696 /* Return the ancestor of CL that's just below the root (i.e., has a parent
698 static struct hol_cluster *
699 hol_cluster_base (struct hol_cluster *cl)
706 /* Return true if CL1 is a child of CL2. */
708 hol_cluster_is_child (const struct hol_cluster *cl1,
709 const struct hol_cluster *cl2)
711 while (cl1 && cl1 != cl2)
716 /* Given the name of an OPTION_DOC option, modifies NAME to start at the tail
717 that should be used for comparisons, and returns true iff it should be
718 treated as a non-option. */
720 canon_doc_option (const char **name)
728 /* Skip initial whitespace. */
729 while (isspace ((unsigned char) **name))
731 /* Decide whether this looks like an option (leading `-') or not. */
732 non_opt = (**name != '-');
733 /* Skip until part of name used for sorting. */
734 while (**name && !isalnum ((unsigned char) **name))
740 #define HOL_ENTRY_PTRCMP(a,b) ((a)->ord < (b)->ord ? -1 : 1)
742 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
745 hol_entry_cmp (const struct hol_entry *entry1,
746 const struct hol_entry *entry2)
748 /* The group numbers by which the entries should be ordered; if either is
749 in a cluster, then this is just the group within the cluster. */
750 int group1 = entry1->group, group2 = entry2->group;
753 if (entry1->cluster != entry2->cluster)
755 /* The entries are not within the same cluster, so we can't compare them
756 directly, we have to use the appropiate clustering level too. */
757 if (! entry1->cluster)
758 /* ENTRY1 is at the `base level', not in a cluster, so we have to
759 compare it's group number with that of the base cluster in which
760 ENTRY2 resides. Note that if they're in the same group, the
761 clustered option always comes laster. */
762 return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
763 else if (! entry2->cluster)
764 /* Likewise, but ENTRY2's not in a cluster. */
765 return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
767 /* Both entries are in clusters, we can just compare the clusters. */
768 return (rc = hol_cluster_cmp (entry1->cluster, entry2->cluster)) ?
769 rc : HOL_ENTRY_PTRCMP (entry1, entry2);
771 else if (group1 == group2)
772 /* The entries are both in the same cluster and group, so compare them
775 int short1 = hol_entry_first_short (entry1);
776 int short2 = hol_entry_first_short (entry2);
777 int doc1 = odoc (entry1->opt);
778 int doc2 = odoc (entry2->opt);
779 const char *long1 = hol_entry_first_long (entry1);
780 const char *long2 = hol_entry_first_long (entry2);
783 doc1 = canon_doc_option (&long1);
785 doc2 = canon_doc_option (&long2);
788 /* `documentation' options always follow normal options (or
789 documentation options that *look* like normal options). */
791 else if (!short1 && !short2 && long1 && long2)
792 /* Only long options. */
793 return (rc = __strcasecmp (long1, long2)) ?
794 rc : HOL_ENTRY_PTRCMP (entry1, entry2);
796 /* Compare short/short, long/short, short/long, using the first
797 character of long options. Entries without *any* valid
798 options (such as options with OPTION_HIDDEN set) will be put
799 first, but as they're not displayed, it doesn't matter where
802 unsigned char first1 = short1 ? short1 : long1 ? *long1 : 0;
803 unsigned char first2 = short2 ? short2 : long2 ? *long2 : 0;
804 /* Use tolower, not _tolower, since only the former is
805 guaranteed to work on something already lower case. */
806 int lower_cmp = tolower (first1) - tolower (first2);
807 /* Compare ignoring case, except when the options are both the
808 same letter, in which case lower-case always comes first. */
809 return lower_cmp ? lower_cmp :
810 (rc = first2 - first1) ?
811 rc : HOL_ENTRY_PTRCMP (entry1, entry2);
815 /* Within the same cluster, but not the same group, so just compare
817 return group_cmp (group1, group2, HOL_ENTRY_PTRCMP (entry1, entry2));
820 /* Version of hol_entry_cmp with correct signature for qsort. */
822 hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
824 return hol_entry_cmp (entry1_v, entry2_v);
827 /* Sort HOL by group and alphabetically by option name (with short options
828 taking precedence over long). Since the sorting is for display purposes
829 only, the shadowing of options isn't effected. */
831 hol_sort (struct hol *hol)
833 if (hol->num_entries > 0)
837 for (i = 0, e = hol->entries; i < hol->num_entries; i++, e++)
839 qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
844 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
845 any in MORE with the same name. */
847 hol_append (struct hol *hol, struct hol *more)
849 struct hol_cluster **cl_end = &hol->clusters;
851 /* Steal MORE's cluster list, and add it to the end of HOL's. */
853 cl_end = &(*cl_end)->next;
854 *cl_end = more->clusters;
858 if (more->num_entries > 0)
860 if (hol->num_entries == 0)
862 hol->num_entries = more->num_entries;
863 hol->entries = more->entries;
864 hol->short_options = more->short_options;
865 more->num_entries = 0; /* Mark MORE's fields as invalid. */
868 /* Append the entries in MORE to those in HOL, taking care to only add
869 non-shadowed SHORT_OPTIONS values. */
874 unsigned num_entries = hol->num_entries + more->num_entries;
875 struct hol_entry *entries =
876 malloc (num_entries * sizeof (struct hol_entry));
877 unsigned hol_so_len = strlen (hol->short_options);
878 char *short_options =
879 malloc (hol_so_len + strlen (more->short_options) + 1);
881 assert (entries && short_options);
882 if (SIZE_MAX <= UINT_MAX)
883 assert (num_entries <= SIZE_MAX / sizeof (struct hol_entry));
885 __mempcpy (__mempcpy (entries, hol->entries,
886 hol->num_entries * sizeof (struct hol_entry)),
888 more->num_entries * sizeof (struct hol_entry));
890 __mempcpy (short_options, hol->short_options, hol_so_len);
892 /* Fix up the short options pointers from HOL. */
893 for (e = entries, left = hol->num_entries; left > 0; e++, left--)
894 e->short_options += (short_options - hol->short_options);
896 /* Now add the short options from MORE, fixing up its entries
898 so = short_options + hol_so_len;
899 more_so = more->short_options;
900 for (left = more->num_entries; left > 0; e++, left--)
903 const struct argp_option *opt;
905 e->short_options = so;
907 for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
910 if (oshort (opt) && ch == opt->key)
911 /* The next short option in MORE_SO, CH, is from OPT. */
913 if (! find_char (ch, short_options,
914 short_options + hol_so_len))
915 /* The short option CH isn't shadowed by HOL's options,
916 so add it to the sum. */
926 free (hol->short_options);
928 hol->entries = entries;
929 hol->num_entries = num_entries;
930 hol->short_options = short_options;
937 /* Inserts enough spaces to make sure STREAM is at column COL. */
939 indent_to (argp_fmtstream_t stream, unsigned col)
941 int needed = col - __argp_fmtstream_point (stream);
943 __argp_fmtstream_putc (stream, ' ');
946 /* Output to STREAM either a space, or a newline if there isn't room for at
947 least ENSURE characters before the right margin. */
949 space (argp_fmtstream_t stream, size_t ensure)
951 if (__argp_fmtstream_point (stream) + ensure
952 >= __argp_fmtstream_rmargin (stream))
953 __argp_fmtstream_putc (stream, '\n');
955 __argp_fmtstream_putc (stream, ' ');
958 /* If the option REAL has an argument, we print it in using the printf
959 format REQ_FMT or OPT_FMT depending on whether it's a required or
960 optional argument. */
962 arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
963 const char *domain, argp_fmtstream_t stream)
967 if (real->flags & OPTION_ARG_OPTIONAL)
968 __argp_fmtstream_printf (stream, opt_fmt,
969 dgettext (domain, real->arg));
971 __argp_fmtstream_printf (stream, req_fmt,
972 dgettext (domain, real->arg));
976 /* Helper functions for hol_entry_help. */
978 /* State used during the execution of hol_help. */
979 struct hol_help_state
981 /* PREV_ENTRY should contain the previous entry printed, or 0. */
982 struct hol_entry *prev_entry;
984 /* If an entry is in a different group from the previous one, and SEP_GROUPS
985 is true, then a blank line will be printed before any output. */
988 /* True if a duplicate option argument was suppressed (only ever set if
989 UPARAMS.dup_args is false). */
990 int suppressed_dup_arg;
993 /* Some state used while printing a help entry (used to communicate with
994 helper functions). See the doc for hol_entry_help for more info, as most
995 of the fields are copied from its arguments. */
998 const struct hol_entry *entry;
999 argp_fmtstream_t stream;
1000 struct hol_help_state *hhstate;
1002 /* True if nothing's been printed so far. */
1005 /* If non-zero, the state that was used to print this help. */
1006 const struct argp_state *state;
1009 /* If a user doc filter should be applied to DOC, do so. */
1011 filter_doc (const char *doc, int key, const struct argp *argp,
1012 const struct argp_state *state)
1014 if (argp->help_filter)
1015 /* We must apply a user filter to this output. */
1017 void *input = __argp_input (argp, state);
1018 return (*argp->help_filter) (key, doc, input);
1025 /* Prints STR as a header line, with the margin lines set appropiately, and
1026 notes the fact that groups should be separated with a blank line. ARGP is
1027 the argp that should dictate any user doc filtering to take place. Note
1028 that the previous wrap margin isn't restored, but the left margin is reset
1031 print_header (const char *str, const struct argp *argp,
1032 struct pentry_state *pest)
1034 const char *tstr = dgettext (argp->argp_domain, str);
1035 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
1041 if (pest->hhstate->prev_entry)
1042 /* Precede with a blank line. */
1043 __argp_fmtstream_putc (pest->stream, '\n');
1044 indent_to (pest->stream, uparams.header_col);
1045 __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
1046 __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
1047 __argp_fmtstream_puts (pest->stream, fstr);
1048 __argp_fmtstream_set_lmargin (pest->stream, 0);
1049 __argp_fmtstream_putc (pest->stream, '\n');
1052 pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
1056 free ((char *) fstr);
1059 /* Inserts a comma if this isn't the first item on the line, and then makes
1060 sure we're at least to column COL. If this *is* the first item on a line,
1061 prints any pending whitespace/headers that should precede this line. Also
1064 comma (unsigned col, struct pentry_state *pest)
1068 const struct hol_entry *pe = pest->hhstate->prev_entry;
1069 const struct hol_cluster *cl = pest->entry->cluster;
1071 if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
1072 __argp_fmtstream_putc (pest->stream, '\n');
1074 if (cl && cl->header && *cl->header
1076 || (pe->cluster != cl
1077 && !hol_cluster_is_child (pe->cluster, cl))))
1078 /* If we're changing clusters, then this must be the start of the
1079 ENTRY's cluster unless that is an ancestor of the previous one
1080 (in which case we had just popped into a sub-cluster for a bit).
1081 If so, then print the cluster's header line. */
1083 int old_wm = __argp_fmtstream_wmargin (pest->stream);
1084 print_header (cl->header, cl->argp, pest);
1085 __argp_fmtstream_set_wmargin (pest->stream, old_wm);
1091 __argp_fmtstream_puts (pest->stream, ", ");
1093 indent_to (pest->stream, col);
1096 /* Print help for ENTRY to STREAM. */
1098 hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
1099 argp_fmtstream_t stream, struct hol_help_state *hhstate)
1102 const struct argp_option *real = entry->opt, *opt;
1103 char *so = entry->short_options;
1104 int have_long_opt = 0; /* We have any long options. */
1105 /* Saved margins. */
1106 int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
1107 int old_wm = __argp_fmtstream_wmargin (stream);
1108 /* PEST is a state block holding some of our variables that we'd like to
1109 share with helper functions. */
1110 struct pentry_state pest;
1113 pest.stream = stream;
1114 pest.hhstate = hhstate;
1119 for (opt = real, num = entry->num; num > 0; opt++, num--)
1120 if (opt->name && ovisible (opt))
1126 /* First emit short options. */
1127 __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
1128 for (opt = real, num = entry->num; num > 0; opt++, num--)
1129 if (oshort (opt) && opt->key == *so)
1130 /* OPT has a valid (non shadowed) short option. */
1134 comma (uparams.short_opt_col, &pest);
1135 __argp_fmtstream_putc (stream, '-');
1136 __argp_fmtstream_putc (stream, *so);
1137 if (!have_long_opt || uparams.dup_args)
1138 arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
1140 hhstate->suppressed_dup_arg = 1;
1145 /* Now, long options. */
1147 /* A `documentation' option. */
1149 __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
1150 for (opt = real, num = entry->num; num > 0; opt++, num--)
1151 if (opt->name && *opt->name && ovisible (opt))
1153 comma (uparams.doc_opt_col, &pest);
1154 /* Calling dgettext here isn't quite right, since sorting will
1155 have been done on the original; but documentation options
1156 should be pretty rare anyway... */
1157 __argp_fmtstream_puts (stream,
1160 dgettext (state->root_argp->argp_domain,
1165 /* A real long option. */
1167 int first_long_opt = 1;
1169 __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
1170 for (opt = real, num = entry->num; num > 0; opt++, num--)
1171 if (opt->name && ovisible (opt))
1173 comma (uparams.long_opt_col, &pest);
1174 __argp_fmtstream_printf (stream, "--%s", opt->name);
1175 if (first_long_opt || uparams.dup_args)
1176 arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
1179 hhstate->suppressed_dup_arg = 1;
1183 /* Next, documentation strings. */
1184 __argp_fmtstream_set_lmargin (stream, 0);
1188 /* Didn't print any switches, what's up? */
1189 if (!oshort (real) && !real->name)
1190 /* This is a group header, print it nicely. */
1191 print_header (real->doc, entry->argp, &pest);
1193 /* Just a totally shadowed option or null header; print nothing. */
1194 goto cleanup; /* Just return, after cleaning up. */
1198 const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
1200 const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
1203 unsigned int col = __argp_fmtstream_point (stream);
1205 __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
1206 __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
1208 if (col > (unsigned int) (uparams.opt_doc_col + 3))
1209 __argp_fmtstream_putc (stream, '\n');
1210 else if (col >= (unsigned int) uparams.opt_doc_col)
1211 __argp_fmtstream_puts (stream, " ");
1213 indent_to (stream, uparams.opt_doc_col);
1215 __argp_fmtstream_puts (stream, fstr);
1217 if (fstr && fstr != tstr)
1218 free ((char *) fstr);
1220 /* Reset the left margin. */
1221 __argp_fmtstream_set_lmargin (stream, 0);
1222 __argp_fmtstream_putc (stream, '\n');
1225 hhstate->prev_entry = entry;
1228 __argp_fmtstream_set_lmargin (stream, old_lm);
1229 __argp_fmtstream_set_wmargin (stream, old_wm);
1232 /* Output a long help message about the options in HOL to STREAM. */
1234 hol_help (struct hol *hol, const struct argp_state *state,
1235 argp_fmtstream_t stream)
1238 struct hol_entry *entry;
1239 struct hol_help_state hhstate = { 0, 0, 0 };
1241 for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
1242 hol_entry_help (entry, state, stream, &hhstate);
1244 if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
1246 const char *tstr = dgettext (state->root_argp->argp_domain, "\
1247 Mandatory or optional arguments to long options are also mandatory or \
1248 optional for any corresponding short options.");
1249 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
1250 state ? state->root_argp : 0, state);
1253 __argp_fmtstream_putc (stream, '\n');
1254 __argp_fmtstream_puts (stream, fstr);
1255 __argp_fmtstream_putc (stream, '\n');
1257 if (fstr && fstr != tstr)
1258 free ((char *) fstr);
1262 /* Helper functions for hol_usage. */
1264 /* If OPT is a short option without an arg, append its key to the string
1265 pointer pointer to by COOKIE, and advance the pointer. */
1267 add_argless_short_opt (const struct argp_option *opt,
1268 const struct argp_option *real,
1269 const char *domain, void *cookie)
1271 char **snao_end = cookie;
1272 if (!(opt->arg || real->arg)
1273 && !((opt->flags | real->flags) & OPTION_NO_USAGE))
1274 *(*snao_end)++ = opt->key;
1278 /* If OPT is a short option with an arg, output a usage entry for it to the
1279 stream pointed at by COOKIE. */
1281 usage_argful_short_opt (const struct argp_option *opt,
1282 const struct argp_option *real,
1283 const char *domain, void *cookie)
1285 argp_fmtstream_t stream = cookie;
1286 const char *arg = opt->arg;
1287 int flags = opt->flags | real->flags;
1292 if (arg && !(flags & OPTION_NO_USAGE))
1294 arg = dgettext (domain, arg);
1296 if (flags & OPTION_ARG_OPTIONAL)
1297 __argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
1300 /* Manually do line wrapping so that it (probably) won't
1301 get wrapped at the embedded space. */
1302 space (stream, 6 + strlen (arg));
1303 __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
1310 /* Output a usage entry for the long option opt to the stream pointed at by
1313 usage_long_opt (const struct argp_option *opt,
1314 const struct argp_option *real,
1315 const char *domain, void *cookie)
1317 argp_fmtstream_t stream = cookie;
1318 const char *arg = opt->arg;
1319 int flags = opt->flags | real->flags;
1324 if (! (flags & OPTION_NO_USAGE) && !odoc (opt))
1328 arg = dgettext (domain, arg);
1329 if (flags & OPTION_ARG_OPTIONAL)
1330 __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
1332 __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
1335 __argp_fmtstream_printf (stream, " [--%s]", opt->name);
1341 /* Print a short usage description for the arguments in HOL to STREAM. */
1343 hol_usage (struct hol *hol, argp_fmtstream_t stream)
1345 if (hol->num_entries > 0)
1348 struct hol_entry *entry;
1349 char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
1350 char *snao_end = short_no_arg_opts;
1352 /* First we put a list of short options without arguments. */
1353 for (entry = hol->entries, nentries = hol->num_entries
1355 ; entry++, nentries--)
1356 hol_entry_short_iterate (entry, add_argless_short_opt,
1357 entry->argp->argp_domain, &snao_end);
1358 if (snao_end > short_no_arg_opts)
1361 __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
1364 /* Now a list of short options *with* arguments. */
1365 for (entry = hol->entries, nentries = hol->num_entries
1367 ; entry++, nentries--)
1368 hol_entry_short_iterate (entry, usage_argful_short_opt,
1369 entry->argp->argp_domain, stream);
1371 /* Finally, a list of long options (whew!). */
1372 for (entry = hol->entries, nentries = hol->num_entries
1374 ; entry++, nentries--)
1375 hol_entry_long_iterate (entry, usage_long_opt,
1376 entry->argp->argp_domain, stream);
1380 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1381 cluster in which ARGP's entries should be clustered, or 0. */
1383 argp_hol (const struct argp *argp, struct hol_cluster *cluster)
1385 const struct argp_child *child = argp->children;
1386 struct hol *hol = make_hol (argp, cluster);
1390 struct hol_cluster *child_cluster =
1391 ((child->group || child->header)
1392 /* Put CHILD->argp within its own cluster. */
1393 ? hol_add_cluster (hol, child->group, child->header,
1394 child - argp->children, cluster, argp)
1395 /* Just merge it into the parent's cluster. */
1397 hol_append (hol, argp_hol (child->argp, child_cluster)) ;
1403 /* Calculate how many different levels with alternative args strings exist in
1406 argp_args_levels (const struct argp *argp)
1409 const struct argp_child *child = argp->children;
1411 if (argp->args_doc && strchr (argp->args_doc, '\n'))
1416 levels += argp_args_levels ((child++)->argp);
1421 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1422 preceded by a space. LEVELS is a pointer to a byte vector the length
1423 returned by argp_args_levels; it should be initialized to zero, and
1424 updated by this routine for the next call if ADVANCE is true. True is
1425 returned as long as there are more patterns to output. */
1427 argp_args_usage (const struct argp *argp, const struct argp_state *state,
1428 char **levels, int advance, argp_fmtstream_t stream)
1430 char *our_level = *levels;
1432 const struct argp_child *child = argp->children;
1433 const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
1434 const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
1438 const char *cp = fdoc;
1439 nl = __strchrnul (cp, '\n');
1441 /* This is a `multi-level' args doc; advance to the correct position
1442 as determined by our state in LEVELS, and update LEVELS. */
1446 for (i = 0; i < *our_level; i++)
1447 cp = nl + 1, nl = __strchrnul (cp, '\n');
1451 /* Manually do line wrapping so that it (probably) won't get wrapped at
1452 any embedded spaces. */
1453 space (stream, 1 + nl - cp);
1455 __argp_fmtstream_write (stream, cp, nl - cp);
1457 if (fdoc && fdoc != tdoc)
1458 free ((char *)fdoc); /* Free user's modified doc string. */
1462 advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
1464 if (advance && multiple)
1466 /* Need to increment our level. */
1468 /* There's more we can do here. */
1471 advance = 0; /* Our parent shouldn't advance also. */
1473 else if (*our_level > 0)
1474 /* We had multiple levels, but used them up; reset to zero. */
1481 /* Print the documentation for ARGP to STREAM; if POST is false, then
1482 everything preceeding a `\v' character in the documentation strings (or
1483 the whole string, for those with none) is printed, otherwise, everything
1484 following the `\v' character (nothing for strings without). Each separate
1485 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1486 then the first is as well. If FIRST_ONLY is true, only the first
1487 occurrence is output. Returns true if anything was output. */
1489 argp_doc (const struct argp *argp, const struct argp_state *state,
1490 int post, int pre_blank, int first_only,
1491 argp_fmtstream_t stream)
1494 const char *inp_text;
1495 size_t inp_text_len = 0;
1496 const char *trans_text;
1499 const struct argp_child *child = argp->children;
1503 char *vt = strchr (argp->doc, '\v');
1510 inp_text_len = vt - argp->doc;
1511 inp_text = __strndup (argp->doc, inp_text_len);
1515 inp_text = post ? 0 : argp->doc;
1516 trans_text = inp_text ? dgettext (argp->argp_domain, inp_text) : NULL;
1519 trans_text = inp_text = 0;
1521 if (argp->help_filter)
1522 /* We have to filter the doc strings. */
1524 input = __argp_input (argp, state);
1526 (*argp->help_filter) (post
1527 ? ARGP_KEY_HELP_POST_DOC
1528 : ARGP_KEY_HELP_PRE_DOC,
1532 text = (const char *) trans_text;
1537 __argp_fmtstream_putc (stream, '\n');
1539 __argp_fmtstream_puts (stream, text);
1541 if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
1542 __argp_fmtstream_putc (stream, '\n');
1547 if (text && text != trans_text)
1548 free ((char *) text); /* Free TEXT returned from the help filter. */
1550 if (inp_text && inp_text_len)
1551 free ((char *) inp_text); /* We copied INP_TEXT, so free it now. */
1553 if (post && argp->help_filter)
1554 /* Now see if we have to output an ARGP_KEY_HELP_EXTRA text. */
1556 text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
1559 if (anything || pre_blank)
1560 __argp_fmtstream_putc (stream, '\n');
1561 __argp_fmtstream_puts (stream, text);
1562 free ((char *) text);
1563 if (__argp_fmtstream_point (stream)
1564 > __argp_fmtstream_lmargin (stream))
1565 __argp_fmtstream_putc (stream, '\n');
1571 while (child->argp && !(first_only && anything))
1573 argp_doc ((child++)->argp, state,
1574 post, anything || pre_blank, first_only,
1580 /* Output a usage message for ARGP to STREAM. If called from
1581 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1582 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1585 _help (const struct argp *argp, const struct argp_state *state, FILE *stream,
1586 unsigned flags, char *name)
1588 int anything = 0; /* Whether we've output anything. */
1589 struct hol *hol = 0;
1590 argp_fmtstream_t fs;
1595 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1596 __flockfile (stream);
1599 if (! uparams.valid)
1600 fill_in_uparams (state);
1602 fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
1605 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1606 __funlockfile (stream);
1611 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
1613 hol = argp_hol (argp, 0);
1615 /* If present, these options always come last. */
1616 hol_set_group (hol, "help", -1);
1617 hol_set_group (hol, "version", -1);
1622 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
1623 /* Print a short `Usage:' message. */
1625 int first_pattern = 1, more_patterns;
1626 size_t num_pattern_levels = argp_args_levels (argp);
1627 char *pattern_levels = alloca (num_pattern_levels);
1629 memset (pattern_levels, 0, num_pattern_levels);
1634 int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
1635 char *levels = pattern_levels;
1638 __argp_fmtstream_printf (fs, "%s %s",
1639 dgettext (argp->argp_domain, "Usage:"),
1642 __argp_fmtstream_printf (fs, "%s %s",
1643 dgettext (argp->argp_domain, " or: "),
1646 /* We set the lmargin as well as the wmargin, because hol_usage
1647 manually wraps options with newline to avoid annoying breaks. */
1648 old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
1650 if (flags & ARGP_HELP_SHORT_USAGE)
1651 /* Just show where the options go. */
1653 if (hol->num_entries > 0)
1654 __argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
1658 /* Actually print the options. */
1660 hol_usage (hol, fs);
1661 flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once. */
1664 more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
1666 __argp_fmtstream_set_wmargin (fs, old_wm);
1667 __argp_fmtstream_set_lmargin (fs, old_lm);
1669 __argp_fmtstream_putc (fs, '\n');
1674 while (more_patterns);
1677 if (flags & ARGP_HELP_PRE_DOC)
1678 anything |= argp_doc (argp, state, 0, 0, 1, fs);
1680 if (flags & ARGP_HELP_SEE)
1682 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
1683 Try `%s --help' or `%s --usage' for more information.\n"),
1688 if (flags & ARGP_HELP_LONG)
1689 /* Print a long, detailed help message. */
1691 /* Print info about all the options. */
1692 if (hol->num_entries > 0)
1695 __argp_fmtstream_putc (fs, '\n');
1696 hol_help (hol, state, fs);
1701 if (flags & ARGP_HELP_POST_DOC)
1702 /* Print any documentation strings at the end. */
1703 anything |= argp_doc (argp, state, 1, anything, 0, fs);
1705 if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
1708 __argp_fmtstream_putc (fs, '\n');
1709 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
1710 "Report bugs to %s.\n"),
1711 argp_program_bug_address);
1715 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1716 __funlockfile (stream);
1722 __argp_fmtstream_free (fs);
1725 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1726 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1727 void __argp_help (const struct argp *argp, FILE *stream,
1728 unsigned flags, char *name)
1730 struct argp_state state;
1731 memset (&state, 0, sizeof state);
1732 state.root_argp = argp;
1733 _help (argp, &state, stream, flags, name);
1736 weak_alias (__argp_help, argp_help)
1739 #if ! (defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME)
1741 __argp_short_program_name (void)
1743 # if HAVE_DECL_PROGRAM_INVOCATION_NAME
1744 return __argp_base_name (program_invocation_name);
1746 /* FIXME: What now? Miles suggests that it is better to use NULL,
1747 but currently the value is passed on directly to fputs_unlocked,
1748 so that requires more changes. */
1750 # warning No reasonable value to return
1751 # endif /* __GNUC__ */
1757 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1758 from the set ARGP_HELP_*. */
1760 __argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
1762 if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
1764 if (state && (state->flags & ARGP_LONG_ONLY))
1765 flags |= ARGP_HELP_LONG_ONLY;
1767 _help (state ? state->root_argp : 0, state, stream, flags,
1768 state ? state->name : __argp_short_program_name ());
1770 if (!state || ! (state->flags & ARGP_NO_EXIT))
1772 if (flags & ARGP_HELP_EXIT_ERR)
1773 exit (argp_err_exit_status);
1774 if (flags & ARGP_HELP_EXIT_OK)
1780 weak_alias (__argp_state_help, argp_state_help)
1783 /* If appropriate, print the printf string FMT and following args, preceded
1784 by the program name and `:', to stderr, and followed by a `Try ... --help'
1785 message, then exit (1). */
1787 __argp_error (const struct argp_state *state, const char *fmt, ...)
1789 if (!state || !(state->flags & ARGP_NO_ERRS))
1791 FILE *stream = state ? state->err_stream : stderr;
1797 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1798 __flockfile (stream);
1804 if (_IO_fwide (stream, 0) > 0)
1808 if (__asprintf (&buf, fmt, ap) < 0)
1811 __fwprintf (stream, L"%s: %s\n",
1812 state ? state->name : __argp_short_program_name (),
1820 fputs_unlocked (state
1821 ? state->name : __argp_short_program_name (),
1823 putc_unlocked (':', stream);
1824 putc_unlocked (' ', stream);
1826 vfprintf (stream, fmt, ap);
1828 putc_unlocked ('\n', stream);
1831 __argp_state_help (state, stream, ARGP_HELP_STD_ERR);
1835 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1836 __funlockfile (stream);
1842 weak_alias (__argp_error, argp_error)
1845 /* Similar to the standard gnu error-reporting function error(), but will
1846 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1847 to STATE->err_stream. This is useful for argument parsing code that is
1848 shared between program startup (when exiting is desired) and runtime
1849 option parsing (when typically an error code is returned instead). The
1850 difference between this function and argp_error is that the latter is for
1851 *parsing errors*, and the former is for other problems that occur during
1852 parsing but don't reflect a (syntactic) problem with the input. */
1854 __argp_failure (const struct argp_state *state, int status, int errnum,
1855 const char *fmt, ...)
1857 if (!state || !(state->flags & ARGP_NO_ERRS))
1859 FILE *stream = state ? state->err_stream : stderr;
1863 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1864 __flockfile (stream);
1868 if (_IO_fwide (stream, 0) > 0)
1869 __fwprintf (stream, L"%s",
1870 state ? state->name : __argp_short_program_name ());
1873 fputs_unlocked (state
1874 ? state->name : __argp_short_program_name (),
1883 if (_IO_fwide (stream, 0) > 0)
1887 if (__asprintf (&buf, fmt, ap) < 0)
1890 __fwprintf (stream, L": %s", buf);
1897 putc_unlocked (':', stream);
1898 putc_unlocked (' ', stream);
1900 vfprintf (stream, fmt, ap);
1911 if (_IO_fwide (stream, 0) > 0)
1912 __fwprintf (stream, L": %s",
1913 __strerror_r (errnum, buf, sizeof (buf)));
1917 char const *s = NULL;
1918 putc_unlocked (':', stream);
1919 putc_unlocked (' ', stream);
1920 #if _LIBC || (HAVE_DECL_STRERROR_R && STRERROR_R_CHAR_P && !defined strerror_r)
1921 s = __strerror_r (errnum, buf, sizeof buf);
1922 #elif HAVE_DECL_STRERROR_R
1923 if (__strerror_r (errnum, buf, sizeof buf) == 0)
1927 if (! s && ! (s = strerror (errnum)))
1928 s = dgettext (state->root_argp->argp_domain,
1929 "Unknown system error");
1936 if (_IO_fwide (stream, 0) > 0)
1937 putwc_unlocked (L'\n', stream);
1940 putc_unlocked ('\n', stream);
1942 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1943 __funlockfile (stream);
1946 if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
1952 weak_alias (__argp_failure, argp_failure)