1 /* Hierarchial argument parsing help output
2 Copyright (C) 1995-2005, 2007, 2009-2010 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 an 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 a 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);
573 __attribute__ ((always_inline))
574 hol_entry_long_iterate (const struct hol_entry *entry,
575 int (*func)(const struct argp_option *opt,
576 const struct argp_option *real,
577 const char *domain, void *cookie),
578 const char *domain, void *cookie)
582 const struct argp_option *opt, *real = entry->opt;
584 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
590 val = (*func)(opt, real, domain, cookie);
596 /* Iterator that returns true for the first short option. */
598 until_short (const struct argp_option *opt, const struct argp_option *real,
599 const char *domain, void *cookie)
601 return oshort (opt) ? opt->key : 0;
604 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
606 hol_entry_first_short (const struct hol_entry *entry)
608 return hol_entry_short_iterate (entry, until_short,
609 entry->argp->argp_domain, 0);
612 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
614 hol_entry_first_long (const struct hol_entry *entry)
616 const struct argp_option *opt;
618 for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
619 if (opt->name && ovisible (opt))
624 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
626 static struct hol_entry *
627 hol_find_entry (struct hol *hol, const char *name)
629 struct hol_entry *entry = hol->entries;
630 unsigned num_entries = hol->num_entries;
632 while (num_entries-- > 0)
634 const struct argp_option *opt = entry->opt;
635 unsigned num_opts = entry->num;
637 while (num_opts-- > 0)
638 if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
649 /* If an entry with the long option NAME occurs in HOL, set it's special
650 sort position to GROUP. */
652 hol_set_group (struct hol *hol, const char *name, int group)
654 struct hol_entry *entry = hol_find_entry (hol, name);
656 entry->group = group;
659 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
660 EQ is what to return if GROUP1 and GROUP2 are the same. */
662 group_cmp (int group1, int group2, int eq)
664 if (group1 == group2)
666 else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
667 return group1 - group2;
669 return group2 - group1;
672 /* Compare clusters CL1 & CL2 by the order that they should appear in
675 hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
677 /* If one cluster is deeper than the other, use its ancestor at the same
678 level, so that finding the common ancestor is straightforward.
680 clN->depth > 0 means that clN->parent != NULL (see hol_add_cluster) */
681 while (cl1->depth > cl2->depth)
683 while (cl2->depth > cl1->depth)
686 /* Now reduce both clusters to their ancestors at the point where both have
687 a common parent; these can be directly compared. */
688 while (cl1->parent != cl2->parent)
689 cl1 = cl1->parent, cl2 = cl2->parent;
691 return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
694 /* Return the ancestor of CL that's just below the root (i.e., has a parent
696 static struct hol_cluster *
697 hol_cluster_base (struct hol_cluster *cl)
704 /* Return true if CL1 is a child of CL2. */
706 hol_cluster_is_child (const struct hol_cluster *cl1,
707 const struct hol_cluster *cl2)
709 while (cl1 && cl1 != cl2)
714 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
715 that should be used for comparisons, and returns true iff it should be
716 treated as a non-option. */
718 canon_doc_option (const char **name)
726 /* Skip initial whitespace. */
727 while (isspace ((unsigned char) **name))
729 /* Decide whether this looks like an option (leading `-') or not. */
730 non_opt = (**name != '-');
731 /* Skip until part of name used for sorting. */
732 while (**name && !isalnum ((unsigned char) **name))
738 #define HOL_ENTRY_PTRCMP(a,b) ((a)->ord < (b)->ord ? -1 : 1)
740 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
743 hol_entry_cmp (const struct hol_entry *entry1,
744 const struct hol_entry *entry2)
746 /* The group numbers by which the entries should be ordered; if either is
747 in a cluster, then this is just the group within the cluster. */
748 int group1 = entry1->group, group2 = entry2->group;
751 if (entry1->cluster != entry2->cluster)
753 /* The entries are not within the same cluster, so we can't compare them
754 directly, we have to use the appropiate clustering level too. */
755 if (! entry1->cluster)
756 /* ENTRY1 is at the `base level', not in a cluster, so we have to
757 compare it's group number with that of the base cluster in which
758 ENTRY2 resides. Note that if they're in the same group, the
759 clustered option always comes laster. */
760 return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
761 else if (! entry2->cluster)
762 /* Likewise, but ENTRY2's not in a cluster. */
763 return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
765 /* Both entries are in clusters, we can just compare the clusters. */
766 return (rc = hol_cluster_cmp (entry1->cluster, entry2->cluster)) ?
767 rc : HOL_ENTRY_PTRCMP (entry1, entry2);
769 else if (group1 == group2)
770 /* The entries are both in the same cluster and group, so compare them
773 int short1 = hol_entry_first_short (entry1);
774 int short2 = hol_entry_first_short (entry2);
775 int doc1 = odoc (entry1->opt);
776 int doc2 = odoc (entry2->opt);
777 const char *long1 = hol_entry_first_long (entry1);
778 const char *long2 = hol_entry_first_long (entry2);
781 doc1 = canon_doc_option (&long1);
783 doc2 = canon_doc_option (&long2);
786 /* `documentation' options always follow normal options (or
787 documentation options that *look* like normal options). */
789 else if (!short1 && !short2 && long1 && long2)
790 /* Only long options. */
791 return (rc = __strcasecmp (long1, long2)) ?
792 rc : HOL_ENTRY_PTRCMP (entry1, entry2);
794 /* Compare short/short, long/short, short/long, using the first
795 character of long options. Entries without *any* valid
796 options (such as options with OPTION_HIDDEN set) will be put
797 first, but as they're not displayed, it doesn't matter where
800 unsigned char first1 = short1 ? short1 : long1 ? *long1 : 0;
801 unsigned char first2 = short2 ? short2 : long2 ? *long2 : 0;
802 /* Use tolower, not _tolower, since only the former is
803 guaranteed to work on something already lower case. */
804 int lower_cmp = tolower (first1) - tolower (first2);
805 /* Compare ignoring case, except when the options are both the
806 same letter, in which case lower-case always comes first. */
807 return lower_cmp ? lower_cmp :
808 (rc = first2 - first1) ?
809 rc : HOL_ENTRY_PTRCMP (entry1, entry2);
813 /* Within the same cluster, but not the same group, so just compare
815 return group_cmp (group1, group2, HOL_ENTRY_PTRCMP (entry1, entry2));
818 /* Version of hol_entry_cmp with correct signature for qsort. */
820 hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
822 return hol_entry_cmp (entry1_v, entry2_v);
825 /* Sort HOL by group and alphabetically by option name (with short options
826 taking precedence over long). Since the sorting is for display purposes
827 only, the shadowing of options isn't effected. */
829 hol_sort (struct hol *hol)
831 if (hol->num_entries > 0)
835 for (i = 0, e = hol->entries; i < hol->num_entries; i++, e++)
837 qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
842 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
843 any in MORE with the same name. */
845 hol_append (struct hol *hol, struct hol *more)
847 struct hol_cluster **cl_end = &hol->clusters;
849 /* Steal MORE's cluster list, and add it to the end of HOL's. */
851 cl_end = &(*cl_end)->next;
852 *cl_end = more->clusters;
856 if (more->num_entries > 0)
858 if (hol->num_entries == 0)
860 hol->num_entries = more->num_entries;
861 hol->entries = more->entries;
862 hol->short_options = more->short_options;
863 more->num_entries = 0; /* Mark MORE's fields as invalid. */
866 /* Append the entries in MORE to those in HOL, taking care to only add
867 non-shadowed SHORT_OPTIONS values. */
872 unsigned num_entries = hol->num_entries + more->num_entries;
873 struct hol_entry *entries =
874 malloc (num_entries * sizeof (struct hol_entry));
875 unsigned hol_so_len = strlen (hol->short_options);
876 char *short_options =
877 malloc (hol_so_len + strlen (more->short_options) + 1);
879 assert (entries && short_options);
880 if (SIZE_MAX <= UINT_MAX)
881 assert (num_entries <= SIZE_MAX / sizeof (struct hol_entry));
883 __mempcpy (__mempcpy (entries, hol->entries,
884 hol->num_entries * sizeof (struct hol_entry)),
886 more->num_entries * sizeof (struct hol_entry));
888 __mempcpy (short_options, hol->short_options, hol_so_len);
890 /* Fix up the short options pointers from HOL. */
891 for (e = entries, left = hol->num_entries; left > 0; e++, left--)
892 e->short_options += (short_options - hol->short_options);
894 /* Now add the short options from MORE, fixing up its entries
896 so = short_options + hol_so_len;
897 more_so = more->short_options;
898 for (left = more->num_entries; left > 0; e++, left--)
901 const struct argp_option *opt;
903 e->short_options = so;
905 for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
908 if (oshort (opt) && ch == opt->key)
909 /* The next short option in MORE_SO, CH, is from OPT. */
911 if (! find_char (ch, short_options,
912 short_options + hol_so_len))
913 /* The short option CH isn't shadowed by HOL's options,
914 so add it to the sum. */
924 free (hol->short_options);
926 hol->entries = entries;
927 hol->num_entries = num_entries;
928 hol->short_options = short_options;
935 /* Inserts enough spaces to make sure STREAM is at column COL. */
937 indent_to (argp_fmtstream_t stream, unsigned col)
939 int needed = col - __argp_fmtstream_point (stream);
941 __argp_fmtstream_putc (stream, ' ');
944 /* Output to STREAM either a space, or a newline if there isn't room for at
945 least ENSURE characters before the right margin. */
947 space (argp_fmtstream_t stream, size_t ensure)
949 if (__argp_fmtstream_point (stream) + ensure
950 >= __argp_fmtstream_rmargin (stream))
951 __argp_fmtstream_putc (stream, '\n');
953 __argp_fmtstream_putc (stream, ' ');
956 /* If the option REAL has an argument, we print it in using the printf
957 format REQ_FMT or OPT_FMT depending on whether it's a required or
958 optional argument. */
960 arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
961 const char *domain, argp_fmtstream_t stream)
965 if (real->flags & OPTION_ARG_OPTIONAL)
966 __argp_fmtstream_printf (stream, opt_fmt,
967 dgettext (domain, real->arg));
969 __argp_fmtstream_printf (stream, req_fmt,
970 dgettext (domain, real->arg));
974 /* Helper functions for hol_entry_help. */
976 /* State used during the execution of hol_help. */
977 struct hol_help_state
979 /* PREV_ENTRY should contain the previous entry printed, or 0. */
980 struct hol_entry *prev_entry;
982 /* If an entry is in a different group from the previous one, and SEP_GROUPS
983 is true, then a blank line will be printed before any output. */
986 /* True if a duplicate option argument was suppressed (only ever set if
987 UPARAMS.dup_args is false). */
988 int suppressed_dup_arg;
991 /* Some state used while printing a help entry (used to communicate with
992 helper functions). See the doc for hol_entry_help for more info, as most
993 of the fields are copied from its arguments. */
996 const struct hol_entry *entry;
997 argp_fmtstream_t stream;
998 struct hol_help_state *hhstate;
1000 /* True if nothing's been printed so far. */
1003 /* If non-zero, the state that was used to print this help. */
1004 const struct argp_state *state;
1007 /* If a user doc filter should be applied to DOC, do so. */
1009 filter_doc (const char *doc, int key, const struct argp *argp,
1010 const struct argp_state *state)
1012 if (argp->help_filter)
1013 /* We must apply a user filter to this output. */
1015 void *input = __argp_input (argp, state);
1016 return (*argp->help_filter) (key, doc, input);
1023 /* Prints STR as a header line, with the margin lines set appropiately, and
1024 notes the fact that groups should be separated with a blank line. ARGP is
1025 the argp that should dictate any user doc filtering to take place. Note
1026 that the previous wrap margin isn't restored, but the left margin is reset
1029 print_header (const char *str, const struct argp *argp,
1030 struct pentry_state *pest)
1032 const char *tstr = dgettext (argp->argp_domain, str);
1033 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
1039 if (pest->hhstate->prev_entry)
1040 /* Precede with a blank line. */
1041 __argp_fmtstream_putc (pest->stream, '\n');
1042 indent_to (pest->stream, uparams.header_col);
1043 __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
1044 __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
1045 __argp_fmtstream_puts (pest->stream, fstr);
1046 __argp_fmtstream_set_lmargin (pest->stream, 0);
1047 __argp_fmtstream_putc (pest->stream, '\n');
1050 pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
1054 free ((char *) fstr);
1057 /* Inserts a comma if this isn't the first item on the line, and then makes
1058 sure we're at least to column COL. If this *is* the first item on a line,
1059 prints any pending whitespace/headers that should precede this line. Also
1062 comma (unsigned col, struct pentry_state *pest)
1066 const struct hol_entry *pe = pest->hhstate->prev_entry;
1067 const struct hol_cluster *cl = pest->entry->cluster;
1069 if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
1070 __argp_fmtstream_putc (pest->stream, '\n');
1072 if (cl && cl->header && *cl->header
1074 || (pe->cluster != cl
1075 && !hol_cluster_is_child (pe->cluster, cl))))
1076 /* If we're changing clusters, then this must be the start of the
1077 ENTRY's cluster unless that is an ancestor of the previous one
1078 (in which case we had just popped into a sub-cluster for a bit).
1079 If so, then print the cluster's header line. */
1081 int old_wm = __argp_fmtstream_wmargin (pest->stream);
1082 print_header (cl->header, cl->argp, pest);
1083 __argp_fmtstream_set_wmargin (pest->stream, old_wm);
1089 __argp_fmtstream_puts (pest->stream, ", ");
1091 indent_to (pest->stream, col);
1094 /* Print help for ENTRY to STREAM. */
1096 hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
1097 argp_fmtstream_t stream, struct hol_help_state *hhstate)
1100 const struct argp_option *real = entry->opt, *opt;
1101 char *so = entry->short_options;
1102 int have_long_opt = 0; /* We have any long options. */
1103 /* Saved margins. */
1104 int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
1105 int old_wm = __argp_fmtstream_wmargin (stream);
1106 /* PEST is a state block holding some of our variables that we'd like to
1107 share with helper functions. */
1108 struct pentry_state pest;
1111 pest.stream = stream;
1112 pest.hhstate = hhstate;
1117 for (opt = real, num = entry->num; num > 0; opt++, num--)
1118 if (opt->name && ovisible (opt))
1124 /* First emit short options. */
1125 __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
1126 for (opt = real, num = entry->num; num > 0; opt++, num--)
1127 if (oshort (opt) && opt->key == *so)
1128 /* OPT has a valid (non shadowed) short option. */
1132 comma (uparams.short_opt_col, &pest);
1133 __argp_fmtstream_putc (stream, '-');
1134 __argp_fmtstream_putc (stream, *so);
1135 if (!have_long_opt || uparams.dup_args)
1136 arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
1138 hhstate->suppressed_dup_arg = 1;
1143 /* Now, long options. */
1145 /* A `documentation' option. */
1147 __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
1148 for (opt = real, num = entry->num; num > 0; opt++, num--)
1149 if (opt->name && *opt->name && ovisible (opt))
1151 comma (uparams.doc_opt_col, &pest);
1152 /* Calling dgettext here isn't quite right, since sorting will
1153 have been done on the original; but documentation options
1154 should be pretty rare anyway... */
1155 __argp_fmtstream_puts (stream,
1158 dgettext (state->root_argp->argp_domain,
1163 /* A real long option. */
1165 int first_long_opt = 1;
1167 __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
1168 for (opt = real, num = entry->num; num > 0; opt++, num--)
1169 if (opt->name && ovisible (opt))
1171 comma (uparams.long_opt_col, &pest);
1172 __argp_fmtstream_printf (stream, "--%s", opt->name);
1173 if (first_long_opt || uparams.dup_args)
1174 arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
1177 hhstate->suppressed_dup_arg = 1;
1181 /* Next, documentation strings. */
1182 __argp_fmtstream_set_lmargin (stream, 0);
1186 /* Didn't print any switches, what's up? */
1187 if (!oshort (real) && !real->name)
1188 /* This is a group header, print it nicely. */
1189 print_header (real->doc, entry->argp, &pest);
1191 /* Just a totally shadowed option or null header; print nothing. */
1192 goto cleanup; /* Just return, after cleaning up. */
1196 const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
1198 const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
1201 unsigned int col = __argp_fmtstream_point (stream);
1203 __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
1204 __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
1206 if (col > (unsigned int) (uparams.opt_doc_col + 3))
1207 __argp_fmtstream_putc (stream, '\n');
1208 else if (col >= (unsigned int) uparams.opt_doc_col)
1209 __argp_fmtstream_puts (stream, " ");
1211 indent_to (stream, uparams.opt_doc_col);
1213 __argp_fmtstream_puts (stream, fstr);
1215 if (fstr && fstr != tstr)
1216 free ((char *) fstr);
1218 /* Reset the left margin. */
1219 __argp_fmtstream_set_lmargin (stream, 0);
1220 __argp_fmtstream_putc (stream, '\n');
1223 hhstate->prev_entry = entry;
1226 __argp_fmtstream_set_lmargin (stream, old_lm);
1227 __argp_fmtstream_set_wmargin (stream, old_wm);
1230 /* Output a long help message about the options in HOL to STREAM. */
1232 hol_help (struct hol *hol, const struct argp_state *state,
1233 argp_fmtstream_t stream)
1236 struct hol_entry *entry;
1237 struct hol_help_state hhstate = { 0, 0, 0 };
1239 for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
1240 hol_entry_help (entry, state, stream, &hhstate);
1242 if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
1244 const char *tstr = dgettext (state->root_argp->argp_domain, "\
1245 Mandatory or optional arguments to long options are also mandatory or \
1246 optional for any corresponding short options.");
1247 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
1248 state ? state->root_argp : 0, state);
1251 __argp_fmtstream_putc (stream, '\n');
1252 __argp_fmtstream_puts (stream, fstr);
1253 __argp_fmtstream_putc (stream, '\n');
1255 if (fstr && fstr != tstr)
1256 free ((char *) fstr);
1260 /* Helper functions for hol_usage. */
1262 /* If OPT is a short option without an arg, append its key to the string
1263 pointer pointer to by COOKIE, and advance the pointer. */
1265 add_argless_short_opt (const struct argp_option *opt,
1266 const struct argp_option *real,
1267 const char *domain, void *cookie)
1269 char **snao_end = cookie;
1270 if (!(opt->arg || real->arg)
1271 && !((opt->flags | real->flags) & OPTION_NO_USAGE))
1272 *(*snao_end)++ = opt->key;
1276 /* If OPT is a short option with an arg, output a usage entry for it to the
1277 stream pointed at by COOKIE. */
1279 usage_argful_short_opt (const struct argp_option *opt,
1280 const struct argp_option *real,
1281 const char *domain, void *cookie)
1283 argp_fmtstream_t stream = cookie;
1284 const char *arg = opt->arg;
1285 int flags = opt->flags | real->flags;
1290 if (arg && !(flags & OPTION_NO_USAGE))
1292 arg = dgettext (domain, arg);
1294 if (flags & OPTION_ARG_OPTIONAL)
1295 __argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
1298 /* Manually do line wrapping so that it (probably) won't
1299 get wrapped at the embedded space. */
1300 space (stream, 6 + strlen (arg));
1301 __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
1308 /* Output a usage entry for the long option opt to the stream pointed at by
1311 usage_long_opt (const struct argp_option *opt,
1312 const struct argp_option *real,
1313 const char *domain, void *cookie)
1315 argp_fmtstream_t stream = cookie;
1316 const char *arg = opt->arg;
1317 int flags = opt->flags | real->flags;
1322 if (! (flags & OPTION_NO_USAGE) && !odoc (opt))
1326 arg = dgettext (domain, arg);
1327 if (flags & OPTION_ARG_OPTIONAL)
1328 __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
1330 __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
1333 __argp_fmtstream_printf (stream, " [--%s]", opt->name);
1339 /* Print a short usage description for the arguments in HOL to STREAM. */
1341 hol_usage (struct hol *hol, argp_fmtstream_t stream)
1343 if (hol->num_entries > 0)
1346 struct hol_entry *entry;
1347 char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
1348 char *snao_end = short_no_arg_opts;
1350 /* First we put a list of short options without arguments. */
1351 for (entry = hol->entries, nentries = hol->num_entries
1353 ; entry++, nentries--)
1354 hol_entry_short_iterate (entry, add_argless_short_opt,
1355 entry->argp->argp_domain, &snao_end);
1356 if (snao_end > short_no_arg_opts)
1359 __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
1362 /* Now a list of short options *with* arguments. */
1363 for (entry = hol->entries, nentries = hol->num_entries
1365 ; entry++, nentries--)
1366 hol_entry_short_iterate (entry, usage_argful_short_opt,
1367 entry->argp->argp_domain, stream);
1369 /* Finally, a list of long options (whew!). */
1370 for (entry = hol->entries, nentries = hol->num_entries
1372 ; entry++, nentries--)
1373 hol_entry_long_iterate (entry, usage_long_opt,
1374 entry->argp->argp_domain, stream);
1378 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1379 cluster in which ARGP's entries should be clustered, or 0. */
1381 argp_hol (const struct argp *argp, struct hol_cluster *cluster)
1383 const struct argp_child *child = argp->children;
1384 struct hol *hol = make_hol (argp, cluster);
1388 struct hol_cluster *child_cluster =
1389 ((child->group || child->header)
1390 /* Put CHILD->argp within its own cluster. */
1391 ? hol_add_cluster (hol, child->group, child->header,
1392 child - argp->children, cluster, argp)
1393 /* Just merge it into the parent's cluster. */
1395 hol_append (hol, argp_hol (child->argp, child_cluster)) ;
1401 /* Calculate how many different levels with alternative args strings exist in
1404 argp_args_levels (const struct argp *argp)
1407 const struct argp_child *child = argp->children;
1409 if (argp->args_doc && strchr (argp->args_doc, '\n'))
1414 levels += argp_args_levels ((child++)->argp);
1419 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1420 preceded by a space. LEVELS is a pointer to a byte vector the length
1421 returned by argp_args_levels; it should be initialized to zero, and
1422 updated by this routine for the next call if ADVANCE is true. True is
1423 returned as long as there are more patterns to output. */
1425 argp_args_usage (const struct argp *argp, const struct argp_state *state,
1426 char **levels, int advance, argp_fmtstream_t stream)
1428 char *our_level = *levels;
1430 const struct argp_child *child = argp->children;
1431 const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
1432 const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
1436 const char *cp = fdoc;
1437 nl = __strchrnul (cp, '\n');
1439 /* This is a `multi-level' args doc; advance to the correct position
1440 as determined by our state in LEVELS, and update LEVELS. */
1444 for (i = 0; i < *our_level; i++)
1445 cp = nl + 1, nl = __strchrnul (cp, '\n');
1449 /* Manually do line wrapping so that it (probably) won't get wrapped at
1450 any embedded spaces. */
1451 space (stream, 1 + nl - cp);
1453 __argp_fmtstream_write (stream, cp, nl - cp);
1455 if (fdoc && fdoc != tdoc)
1456 free ((char *)fdoc); /* Free user's modified doc string. */
1460 advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
1462 if (advance && multiple)
1464 /* Need to increment our level. */
1466 /* There's more we can do here. */
1469 advance = 0; /* Our parent shouldn't advance also. */
1471 else if (*our_level > 0)
1472 /* We had multiple levels, but used them up; reset to zero. */
1479 /* Print the documentation for ARGP to STREAM; if POST is false, then
1480 everything preceeding a `\v' character in the documentation strings (or
1481 the whole string, for those with none) is printed, otherwise, everything
1482 following the `\v' character (nothing for strings without). Each separate
1483 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1484 then the first is as well. If FIRST_ONLY is true, only the first
1485 occurrence is output. Returns true if anything was output. */
1487 argp_doc (const struct argp *argp, const struct argp_state *state,
1488 int post, int pre_blank, int first_only,
1489 argp_fmtstream_t stream)
1492 const char *inp_text;
1493 size_t inp_text_len = 0;
1494 const char *trans_text;
1497 const struct argp_child *child = argp->children;
1501 char *vt = strchr (argp->doc, '\v');
1508 inp_text_len = vt - argp->doc;
1509 inp_text = __strndup (argp->doc, inp_text_len);
1513 inp_text = post ? 0 : argp->doc;
1514 trans_text = inp_text ? dgettext (argp->argp_domain, inp_text) : NULL;
1517 trans_text = inp_text = 0;
1519 if (argp->help_filter)
1520 /* We have to filter the doc strings. */
1522 input = __argp_input (argp, state);
1524 (*argp->help_filter) (post
1525 ? ARGP_KEY_HELP_POST_DOC
1526 : ARGP_KEY_HELP_PRE_DOC,
1530 text = (const char *) trans_text;
1535 __argp_fmtstream_putc (stream, '\n');
1537 __argp_fmtstream_puts (stream, text);
1539 if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
1540 __argp_fmtstream_putc (stream, '\n');
1545 if (text && text != trans_text)
1546 free ((char *) text); /* Free TEXT returned from the help filter. */
1548 if (inp_text && inp_text_len)
1549 free ((char *) inp_text); /* We copied INP_TEXT, so free it now. */
1551 if (post && argp->help_filter)
1552 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1554 text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
1557 if (anything || pre_blank)
1558 __argp_fmtstream_putc (stream, '\n');
1559 __argp_fmtstream_puts (stream, text);
1560 free ((char *) text);
1561 if (__argp_fmtstream_point (stream)
1562 > __argp_fmtstream_lmargin (stream))
1563 __argp_fmtstream_putc (stream, '\n');
1569 while (child->argp && !(first_only && anything))
1571 argp_doc ((child++)->argp, state,
1572 post, anything || pre_blank, first_only,
1578 /* Output a usage message for ARGP to STREAM. If called from
1579 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1580 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1583 _help (const struct argp *argp, const struct argp_state *state, FILE *stream,
1584 unsigned flags, char *name)
1586 int anything = 0; /* Whether we've output anything. */
1587 struct hol *hol = 0;
1588 argp_fmtstream_t fs;
1593 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1594 __flockfile (stream);
1597 if (! uparams.valid)
1598 fill_in_uparams (state);
1600 fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
1603 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1604 __funlockfile (stream);
1609 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
1611 hol = argp_hol (argp, 0);
1613 /* If present, these options always come last. */
1614 hol_set_group (hol, "help", -1);
1615 hol_set_group (hol, "version", -1);
1620 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
1621 /* Print a short `Usage:' message. */
1623 int first_pattern = 1, more_patterns;
1624 size_t num_pattern_levels = argp_args_levels (argp);
1625 char *pattern_levels = alloca (num_pattern_levels);
1627 memset (pattern_levels, 0, num_pattern_levels);
1632 int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
1633 char *levels = pattern_levels;
1636 __argp_fmtstream_printf (fs, "%s %s",
1637 dgettext (argp->argp_domain, "Usage:"),
1640 __argp_fmtstream_printf (fs, "%s %s",
1641 dgettext (argp->argp_domain, " or: "),
1644 /* We set the lmargin as well as the wmargin, because hol_usage
1645 manually wraps options with newline to avoid annoying breaks. */
1646 old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
1648 if (flags & ARGP_HELP_SHORT_USAGE)
1649 /* Just show where the options go. */
1651 if (hol->num_entries > 0)
1652 __argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
1656 /* Actually print the options. */
1658 hol_usage (hol, fs);
1659 flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once. */
1662 more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
1664 __argp_fmtstream_set_wmargin (fs, old_wm);
1665 __argp_fmtstream_set_lmargin (fs, old_lm);
1667 __argp_fmtstream_putc (fs, '\n');
1672 while (more_patterns);
1675 if (flags & ARGP_HELP_PRE_DOC)
1676 anything |= argp_doc (argp, state, 0, 0, 1, fs);
1678 if (flags & ARGP_HELP_SEE)
1680 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
1681 Try `%s --help' or `%s --usage' for more information.\n"),
1686 if (flags & ARGP_HELP_LONG)
1687 /* Print a long, detailed help message. */
1689 /* Print info about all the options. */
1690 if (hol->num_entries > 0)
1693 __argp_fmtstream_putc (fs, '\n');
1694 hol_help (hol, state, fs);
1699 if (flags & ARGP_HELP_POST_DOC)
1700 /* Print any documentation strings at the end. */
1701 anything |= argp_doc (argp, state, 1, anything, 0, fs);
1703 if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
1706 __argp_fmtstream_putc (fs, '\n');
1707 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
1708 "Report bugs to %s.\n"),
1709 argp_program_bug_address);
1713 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1714 __funlockfile (stream);
1720 __argp_fmtstream_free (fs);
1723 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1724 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1725 void __argp_help (const struct argp *argp, FILE *stream,
1726 unsigned flags, char *name)
1728 struct argp_state state;
1729 memset (&state, 0, sizeof state);
1730 state.root_argp = argp;
1731 _help (argp, &state, stream, flags, name);
1734 weak_alias (__argp_help, argp_help)
1737 #if ! (defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME)
1739 __argp_short_program_name (void)
1741 # if HAVE_DECL_PROGRAM_INVOCATION_NAME
1742 return __argp_base_name (program_invocation_name);
1744 /* FIXME: What now? Miles suggests that it is better to use NULL,
1745 but currently the value is passed on directly to fputs_unlocked,
1746 so that requires more changes. */
1748 # warning No reasonable value to return
1749 # endif /* __GNUC__ */
1755 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1756 from the set ARGP_HELP_*. */
1758 __argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
1760 if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
1762 if (state && (state->flags & ARGP_LONG_ONLY))
1763 flags |= ARGP_HELP_LONG_ONLY;
1765 _help (state ? state->root_argp : 0, state, stream, flags,
1766 state ? state->name : __argp_short_program_name ());
1768 if (!state || ! (state->flags & ARGP_NO_EXIT))
1770 if (flags & ARGP_HELP_EXIT_ERR)
1771 exit (argp_err_exit_status);
1772 if (flags & ARGP_HELP_EXIT_OK)
1778 weak_alias (__argp_state_help, argp_state_help)
1781 /* If appropriate, print the printf string FMT and following args, preceded
1782 by the program name and `:', to stderr, and followed by a `Try ... --help'
1783 message, then exit (1). */
1785 __argp_error (const struct argp_state *state, const char *fmt, ...)
1787 if (!state || !(state->flags & ARGP_NO_ERRS))
1789 FILE *stream = state ? state->err_stream : stderr;
1795 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1796 __flockfile (stream);
1802 if (_IO_fwide (stream, 0) > 0)
1806 if (__asprintf (&buf, fmt, ap) < 0)
1809 __fwprintf (stream, L"%s: %s\n",
1810 state ? state->name : __argp_short_program_name (),
1818 fputs_unlocked (state
1819 ? state->name : __argp_short_program_name (),
1821 putc_unlocked (':', stream);
1822 putc_unlocked (' ', stream);
1824 vfprintf (stream, fmt, ap);
1826 putc_unlocked ('\n', stream);
1829 __argp_state_help (state, stream, ARGP_HELP_STD_ERR);
1833 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1834 __funlockfile (stream);
1840 weak_alias (__argp_error, argp_error)
1843 /* Similar to the standard gnu error-reporting function error(), but will
1844 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1845 to STATE->err_stream. This is useful for argument parsing code that is
1846 shared between program startup (when exiting is desired) and runtime
1847 option parsing (when typically an error code is returned instead). The
1848 difference between this function and argp_error is that the latter is for
1849 *parsing errors*, and the former is for other problems that occur during
1850 parsing but don't reflect a (syntactic) problem with the input. */
1852 __argp_failure (const struct argp_state *state, int status, int errnum,
1853 const char *fmt, ...)
1855 if (!state || !(state->flags & ARGP_NO_ERRS))
1857 FILE *stream = state ? state->err_stream : stderr;
1861 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1862 __flockfile (stream);
1866 if (_IO_fwide (stream, 0) > 0)
1867 __fwprintf (stream, L"%s",
1868 state ? state->name : __argp_short_program_name ());
1871 fputs_unlocked (state
1872 ? state->name : __argp_short_program_name (),
1881 if (_IO_fwide (stream, 0) > 0)
1885 if (__asprintf (&buf, fmt, ap) < 0)
1888 __fwprintf (stream, L": %s", buf);
1895 putc_unlocked (':', stream);
1896 putc_unlocked (' ', stream);
1898 vfprintf (stream, fmt, ap);
1909 if (_IO_fwide (stream, 0) > 0)
1910 __fwprintf (stream, L": %s",
1911 __strerror_r (errnum, buf, sizeof (buf)));
1915 char const *s = NULL;
1916 putc_unlocked (':', stream);
1917 putc_unlocked (' ', stream);
1918 #if _LIBC || (HAVE_DECL_STRERROR_R && STRERROR_R_CHAR_P)
1919 s = __strerror_r (errnum, buf, sizeof buf);
1920 #elif HAVE_DECL_STRERROR_R
1921 if (__strerror_r (errnum, buf, sizeof buf) == 0)
1925 if (! s && ! (s = strerror (errnum)))
1926 s = dgettext (state->root_argp->argp_domain,
1927 "Unknown system error");
1934 if (_IO_fwide (stream, 0) > 0)
1935 putwc_unlocked (L'\n', stream);
1938 putc_unlocked ('\n', stream);
1940 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1941 __funlockfile (stream);
1944 if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
1950 weak_alias (__argp_failure, argp_failure)