1 /* Hierarchial argument parsing help output
2 Copyright (C) 1995-2003, 2004, 2005 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 2, or (at your option)
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 along
17 with this program; if not, write to the Free Software Foundation,
18 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
21 # define _GNU_SOURCE 1
44 # define dgettext(domain, msgid) \
45 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
51 #include "argp-fmtstream.h"
52 #include "argp-namefrob.h"
56 # define SIZE_MAX ((size_t) -1)
59 /* User-selectable (using an environment variable) formatting parameters.
61 These may be specified in an environment variable called `ARGP_HELP_FMT',
62 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
63 Where VALn must be a positive integer. The list of variables is in the
64 UPARAM_NAMES vector, below. */
66 /* Default parameters. */
67 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
68 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
69 #define SHORT_OPT_COL 2 /* column in which short options start */
70 #define LONG_OPT_COL 6 /* column in which long options start */
71 #define DOC_OPT_COL 2 /* column in which doc options start */
72 #define OPT_DOC_COL 29 /* column in which option text starts */
73 #define HEADER_COL 1 /* column in which group headers are printed */
74 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
75 #define RMARGIN 79 /* right margin used for wrapping */
77 /* User-selectable (using an environment variable) formatting parameters.
78 They must all be of type `int' for the parsing code to work. */
81 /* If true, arguments for an option are shown with both short and long
82 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
83 If false, then if an option has both, the argument is only shown with
84 the long one, e.g., `-x, --longx=ARG', and a message indicating that
85 this really means both is printed below the options. */
88 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
89 been suppressed, an explanatory message should be printed. */
92 /* Various output columns. */
101 int valid; /* True when the values in here are valid. */
104 /* This is a global variable, as user options are only ever read once. */
105 static struct uparams uparams = {
106 DUP_ARGS, DUP_ARGS_NOTE,
107 SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,
108 USAGE_INDENT, RMARGIN,
112 /* A particular uparam, and what the user name is. */
115 const char *name; /* User name. */
116 int is_bool; /* Whether it's `boolean'. */
117 size_t uparams_offs; /* Location of the (int) field in UPARAMS. */
120 /* The name-field mappings we know about. */
121 static const struct uparam_name uparam_names[] =
123 { "dup-args", 1, offsetof (struct uparams, dup_args) },
124 { "dup-args-note", 1, offsetof (struct uparams, dup_args_note) },
125 { "short-opt-col", 0, offsetof (struct uparams, short_opt_col) },
126 { "long-opt-col", 0, offsetof (struct uparams, long_opt_col) },
127 { "doc-opt-col", 0, offsetof (struct uparams, doc_opt_col) },
128 { "opt-doc-col", 0, offsetof (struct uparams, opt_doc_col) },
129 { "header-col", 0, offsetof (struct uparams, header_col) },
130 { "usage-indent", 0, offsetof (struct uparams, usage_indent) },
131 { "rmargin", 0, offsetof (struct uparams, rmargin) },
135 /* Read user options from the environment, and fill in UPARAMS appropiately. */
137 fill_in_uparams (const struct argp_state *state)
139 const char *var = getenv ("ARGP_HELP_FMT");
141 #define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
152 const struct uparam_name *un;
153 int unspec = 0, val = 0;
154 const char *arg = var;
156 while (isalnum (*arg) || *arg == '-' || *arg == '_')
162 if (*arg == '\0' || *arg == ',')
164 else if (*arg == '=')
172 if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')
181 else if (isdigit (*arg))
184 while (isdigit (*arg))
189 for (un = uparam_names; un->name; un++)
190 if (strlen (un->name) == var_len
191 && strncmp (var, un->name, var_len) == 0)
193 if (unspec && !un->is_bool)
194 __argp_failure (state, 0, 0,
195 dgettext (state->root_argp->argp_domain, "\
196 %.*s: ARGP_HELP_FMT parameter requires a value"),
199 *(int *)((char *)&uparams + un->uparams_offs) = val;
203 __argp_failure (state, 0, 0,
204 dgettext (state->root_argp->argp_domain, "\
205 %.*s: Unknown ARGP_HELP_FMT parameter"),
214 __argp_failure (state, 0, 0,
215 dgettext (state->root_argp->argp_domain,
216 "Garbage in ARGP_HELP_FMT: %s"), var);
222 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
223 whether OPT is displayed or used in sorting, not option shadowing. */
224 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
226 /* Returns true if OPT is an alias for an earlier option. */
227 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
229 /* Returns true if OPT is an documentation-only entry. */
230 #define odoc(opt) ((opt)->flags & OPTION_DOC)
232 /* Returns true if OPT should not be translated */
233 #define onotrans(opt) ((opt)->flags & OPTION_NO_TRANS)
235 /* Returns true if OPT is the end-of-list marker for a list of options. */
236 #define oend(opt) __option_is_end (opt)
238 /* Returns true if OPT has a short option. */
239 #define oshort(opt) __option_is_short (opt)
242 The help format for a particular option is like:
244 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
246 Where ARG will be omitted if there's no argument, for this option, or
247 will be surrounded by "[" and "]" appropiately if the argument is
248 optional. The documentation string is word-wrapped appropiately, and if
249 the list of options is long enough, it will be started on a separate line.
250 If there are no short options for a given option, the first long option is
251 indented slighly in a way that's supposed to make most long options appear
252 to be in a separate column.
254 For example, the following output (from ps):
256 -p PID, --pid=PID List the process PID
257 --pgrp=PGRP List processes in the process group PGRP
258 -P, -x, --no-parent Include processes without parents
259 -Q, --all-fields Don't elide unusable fields (normally if there's
260 some reason ps can't print a field for any
261 process, it's removed from the output entirely)
262 -r, --reverse, --gratuitously-long-reverse-option
263 Reverse the order of any sort
264 --session[=SID] Add the processes from the session SID (which
265 defaults to the sid of the current process)
267 Here are some more options:
268 -f ZOT, --foonly=ZOT Glork a foonly
269 -z, --zaza Snit a zar
271 -?, --help Give this help list
272 --usage Give a short usage message
273 -V, --version Print program version
275 The struct argp_option array for the above could look like:
278 {"pid", 'p', "PID", 0, "List the process PID"},
279 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
280 {"no-parent", 'P', 0, 0, "Include processes without parents"},
281 {0, 'x', 0, OPTION_ALIAS},
282 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
283 " if there's some reason ps can't"
284 " print a field for any process, it's"
285 " removed from the output entirely)" },
286 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
287 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
288 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
289 "Add the processes from the session"
290 " SID (which defaults to the sid of"
291 " the current process)" },
293 {0,0,0,0, "Here are some more options:"},
294 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
295 {"zaza", 'z', 0, 0, "Snit a zar"},
300 Note that the last three options are automatically supplied by argp_parse,
301 unless you tell it not to with ARGP_NO_HELP.
305 /* Returns true if CH occurs between BEG and END. */
307 find_char (char ch, char *beg, char *end)
317 struct hol_cluster; /* fwd decl */
322 const struct argp_option *opt;
323 /* Number of options (including aliases). */
326 /* A pointers into the HOL's short_options field, to the first short option
327 letter for this entry. The order of the characters following this point
328 corresponds to the order of options pointed to by OPT, and there are at
329 most NUM. A short option recorded in a option following OPT is only
330 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
331 probably been shadowed by some other entry). */
334 /* Entries are sorted by their group first, in the order:
335 1, 2, ..., n, 0, -m, ..., -2, -1
336 and then alphabetically within each group. The default is 0. */
339 /* The cluster of options this entry belongs to, or 0 if none. */
340 struct hol_cluster *cluster;
342 /* The argp from which this option came. */
343 const struct argp *argp;
346 /* A cluster of entries to reflect the argp tree structure. */
349 /* A descriptive header printed before options in this cluster. */
352 /* Used to order clusters within the same group with the same parent,
353 according to the order in which they occurred in the parent argp's child
357 /* How to sort this cluster with respect to options and other clusters at the
358 same depth (clusters always follow options in the same group). */
361 /* The cluster to which this cluster belongs, or 0 if it's at the base
363 struct hol_cluster *parent;
365 /* The argp from which this cluster is (eventually) derived. */
366 const struct argp *argp;
368 /* The distance this cluster is from the root. */
371 /* Clusters in a given hol are kept in a linked list, to make freeing them
373 struct hol_cluster *next;
376 /* A list of options for help. */
379 /* An array of hol_entry's. */
380 struct hol_entry *entries;
381 /* The number of entries in this hol. If this field is zero, the others
383 unsigned num_entries;
385 /* A string containing all short options in this HOL. Each entry contains
386 pointers into this string, so the order can't be messed with blindly. */
389 /* Clusters of entries in this hol. */
390 struct hol_cluster *clusters;
393 /* Create a struct hol from the options in ARGP. CLUSTER is the
394 hol_cluster in which these entries occur, or 0, if at the root. */
396 make_hol (const struct argp *argp, struct hol_cluster *cluster)
399 const struct argp_option *o;
400 const struct argp_option *opts = argp->options;
401 struct hol_entry *entry;
402 unsigned num_short_options = 0;
403 struct hol *hol = malloc (sizeof (struct hol));
407 hol->num_entries = 0;
414 /* The first option must not be an alias. */
415 assert (! oalias (opts));
417 /* Calculate the space needed. */
418 for (o = opts; ! oend (o); o++)
423 num_short_options++; /* This is an upper bound. */
426 hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);
427 hol->short_options = malloc (num_short_options + 1);
429 assert (hol->entries && hol->short_options);
430 if (SIZE_MAX <= UINT_MAX)
431 assert (hol->num_entries <= SIZE_MAX / sizeof (struct hol_entry));
433 /* Fill in the entries. */
434 so = hol->short_options;
435 for (o = opts, entry = hol->entries; ! oend (o); entry++)
439 entry->short_options = so;
440 entry->group = cur_group =
443 : ((!o->name && !o->key)
446 entry->cluster = cluster;
452 if (oshort (o) && ! find_char (o->key, hol->short_options, so))
453 /* O has a valid short option which hasn't already been used.*/
457 while (! oend (o) && oalias (o));
459 *so = '\0'; /* null terminated so we can find the length */
465 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
466 associated argp child list entry), INDEX, and PARENT, and return a pointer
467 to it. ARGP is the argp that this cluster results from. */
468 static struct hol_cluster *
469 hol_add_cluster (struct hol *hol, int group, const char *header, int index,
470 struct hol_cluster *parent, const struct argp *argp)
472 struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));
481 cl->depth = parent ? parent->depth + 1 : 0;
483 cl->next = hol->clusters;
489 /* Free HOL and any resources it uses. */
491 hol_free (struct hol *hol)
493 struct hol_cluster *cl = hol->clusters;
497 struct hol_cluster *next = cl->next;
502 if (hol->num_entries > 0)
505 free (hol->short_options);
512 hol_entry_short_iterate (const struct hol_entry *entry,
513 int (*func)(const struct argp_option *opt,
514 const struct argp_option *real,
515 const char *domain, void *cookie),
516 const char *domain, void *cookie)
520 const struct argp_option *opt, *real = entry->opt;
521 char *so = entry->short_options;
523 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
524 if (oshort (opt) && *so == opt->key)
529 val = (*func)(opt, real, domain, cookie);
537 __attribute__ ((always_inline))
538 hol_entry_long_iterate (const struct hol_entry *entry,
539 int (*func)(const struct argp_option *opt,
540 const struct argp_option *real,
541 const char *domain, void *cookie),
542 const char *domain, void *cookie)
546 const struct argp_option *opt, *real = entry->opt;
548 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
554 val = (*func)(opt, real, domain, cookie);
560 /* Iterator that returns true for the first short option. */
562 until_short (const struct argp_option *opt, const struct argp_option *real,
563 const char *domain, void *cookie)
565 return oshort (opt) ? opt->key : 0;
568 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
570 hol_entry_first_short (const struct hol_entry *entry)
572 return hol_entry_short_iterate (entry, until_short,
573 entry->argp->argp_domain, 0);
576 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
578 hol_entry_first_long (const struct hol_entry *entry)
580 const struct argp_option *opt;
582 for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
583 if (opt->name && ovisible (opt))
588 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
590 static struct hol_entry *
591 hol_find_entry (struct hol *hol, const char *name)
593 struct hol_entry *entry = hol->entries;
594 unsigned num_entries = hol->num_entries;
596 while (num_entries-- > 0)
598 const struct argp_option *opt = entry->opt;
599 unsigned num_opts = entry->num;
601 while (num_opts-- > 0)
602 if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
613 /* If an entry with the long option NAME occurs in HOL, set it's special
614 sort position to GROUP. */
616 hol_set_group (struct hol *hol, const char *name, int group)
618 struct hol_entry *entry = hol_find_entry (hol, name);
620 entry->group = group;
623 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
624 EQ is what to return if GROUP1 and GROUP2 are the same. */
626 group_cmp (int group1, int group2, int eq)
628 if (group1 == group2)
630 else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
631 return group1 - group2;
633 return group2 - group1;
636 /* Compare clusters CL1 & CL2 by the order that they should appear in
639 hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
641 /* If one cluster is deeper than the other, use its ancestor at the same
642 level, so that finding the common ancestor is straightforward. */
643 while (cl1->depth < cl2->depth)
645 while (cl2->depth < cl1->depth)
648 /* Now reduce both clusters to their ancestors at the point where both have
649 a common parent; these can be directly compared. */
650 while (cl1->parent != cl2->parent)
651 cl1 = cl1->parent, cl2 = cl2->parent;
653 return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
656 /* Return the ancestor of CL that's just below the root (i.e., has a parent
658 static struct hol_cluster *
659 hol_cluster_base (struct hol_cluster *cl)
666 /* Return true if CL1 is a child of CL2. */
668 hol_cluster_is_child (const struct hol_cluster *cl1,
669 const struct hol_cluster *cl2)
671 while (cl1 && cl1 != cl2)
676 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
677 that should be used for comparisons, and returns true iff it should be
678 treated as a non-option. */
680 canon_doc_option (const char **name)
688 /* Skip initial whitespace. */
689 while (isspace (**name))
691 /* Decide whether this looks like an option (leading `-') or not. */
692 non_opt = (**name != '-');
693 /* Skip until part of name used for sorting. */
694 while (**name && !isalnum (**name))
700 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
703 hol_entry_cmp (const struct hol_entry *entry1,
704 const struct hol_entry *entry2)
706 /* The group numbers by which the entries should be ordered; if either is
707 in a cluster, then this is just the group within the cluster. */
708 int group1 = entry1->group, group2 = entry2->group;
710 if (entry1->cluster != entry2->cluster)
712 /* The entries are not within the same cluster, so we can't compare them
713 directly, we have to use the appropiate clustering level too. */
714 if (! entry1->cluster)
715 /* ENTRY1 is at the `base level', not in a cluster, so we have to
716 compare it's group number with that of the base cluster in which
717 ENTRY2 resides. Note that if they're in the same group, the
718 clustered option always comes laster. */
719 return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
720 else if (! entry2->cluster)
721 /* Likewise, but ENTRY2's not in a cluster. */
722 return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
724 /* Both entries are in clusters, we can just compare the clusters. */
725 return hol_cluster_cmp (entry1->cluster, entry2->cluster);
727 else if (group1 == group2)
728 /* The entries are both in the same cluster and group, so compare them
731 int short1 = hol_entry_first_short (entry1);
732 int short2 = hol_entry_first_short (entry2);
733 int doc1 = odoc (entry1->opt);
734 int doc2 = odoc (entry2->opt);
735 const char *long1 = hol_entry_first_long (entry1);
736 const char *long2 = hol_entry_first_long (entry2);
739 doc1 = canon_doc_option (&long1);
741 doc2 = canon_doc_option (&long2);
744 /* `documentation' options always follow normal options (or
745 documentation options that *look* like normal options). */
747 else if (!short1 && !short2 && long1 && long2)
748 /* Only long options. */
749 return __strcasecmp (long1, long2);
751 /* Compare short/short, long/short, short/long, using the first
752 character of long options. Entries without *any* valid
753 options (such as options with OPTION_HIDDEN set) will be put
754 first, but as they're not displayed, it doesn't matter where
757 char first1 = short1 ? short1 : long1 ? *long1 : 0;
758 char first2 = short2 ? short2 : long2 ? *long2 : 0;
760 int lower_cmp = _tolower (first1) - _tolower (first2);
762 int lower_cmp = tolower (first1) - tolower (first2);
764 /* Compare ignoring case, except when the options are both the
765 same letter, in which case lower-case always comes first. */
766 return lower_cmp ? lower_cmp : first2 - first1;
770 /* Within the same cluster, but not the same group, so just compare
772 return group_cmp (group1, group2, 0);
775 /* Version of hol_entry_cmp with correct signature for qsort. */
777 hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
779 return hol_entry_cmp (entry1_v, entry2_v);
782 /* Sort HOL by group and alphabetically by option name (with short options
783 taking precedence over long). Since the sorting is for display purposes
784 only, the shadowing of options isn't effected. */
786 hol_sort (struct hol *hol)
788 if (hol->num_entries > 0)
789 qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
793 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
794 any in MORE with the same name. */
796 hol_append (struct hol *hol, struct hol *more)
798 struct hol_cluster **cl_end = &hol->clusters;
800 /* Steal MORE's cluster list, and add it to the end of HOL's. */
802 cl_end = &(*cl_end)->next;
803 *cl_end = more->clusters;
807 if (more->num_entries > 0)
809 if (hol->num_entries == 0)
811 hol->num_entries = more->num_entries;
812 hol->entries = more->entries;
813 hol->short_options = more->short_options;
814 more->num_entries = 0; /* Mark MORE's fields as invalid. */
817 /* Append the entries in MORE to those in HOL, taking care to only add
818 non-shadowed SHORT_OPTIONS values. */
823 unsigned num_entries = hol->num_entries + more->num_entries;
824 struct hol_entry *entries =
825 malloc (num_entries * sizeof (struct hol_entry));
826 unsigned hol_so_len = strlen (hol->short_options);
827 char *short_options =
828 malloc (hol_so_len + strlen (more->short_options) + 1);
830 assert (entries && short_options);
831 if (SIZE_MAX <= UINT_MAX)
832 assert (num_entries <= SIZE_MAX / sizeof (struct hol_entry));
834 __mempcpy (__mempcpy (entries, hol->entries,
835 hol->num_entries * sizeof (struct hol_entry)),
837 more->num_entries * sizeof (struct hol_entry));
839 __mempcpy (short_options, hol->short_options, hol_so_len);
841 /* Fix up the short options pointers from HOL. */
842 for (e = entries, left = hol->num_entries; left > 0; e++, left--)
843 e->short_options += (short_options - hol->short_options);
845 /* Now add the short options from MORE, fixing up its entries
847 so = short_options + hol_so_len;
848 more_so = more->short_options;
849 for (left = more->num_entries; left > 0; e++, left--)
852 const struct argp_option *opt;
854 e->short_options = so;
856 for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
859 if (oshort (opt) && ch == opt->key)
860 /* The next short option in MORE_SO, CH, is from OPT. */
862 if (! find_char (ch, short_options,
863 short_options + hol_so_len))
864 /* The short option CH isn't shadowed by HOL's options,
865 so add it to the sum. */
875 free (hol->short_options);
877 hol->entries = entries;
878 hol->num_entries = num_entries;
879 hol->short_options = short_options;
886 /* Inserts enough spaces to make sure STREAM is at column COL. */
888 indent_to (argp_fmtstream_t stream, unsigned col)
890 int needed = col - __argp_fmtstream_point (stream);
892 __argp_fmtstream_putc (stream, ' ');
895 /* Output to STREAM either a space, or a newline if there isn't room for at
896 least ENSURE characters before the right margin. */
898 space (argp_fmtstream_t stream, size_t ensure)
900 if (__argp_fmtstream_point (stream) + ensure
901 >= __argp_fmtstream_rmargin (stream))
902 __argp_fmtstream_putc (stream, '\n');
904 __argp_fmtstream_putc (stream, ' ');
907 /* If the option REAL has an argument, we print it in using the printf
908 format REQ_FMT or OPT_FMT depending on whether it's a required or
909 optional argument. */
911 arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
912 const char *domain, argp_fmtstream_t stream)
916 if (real->flags & OPTION_ARG_OPTIONAL)
917 __argp_fmtstream_printf (stream, opt_fmt,
918 dgettext (domain, real->arg));
920 __argp_fmtstream_printf (stream, req_fmt,
921 dgettext (domain, real->arg));
925 /* Helper functions for hol_entry_help. */
927 /* State used during the execution of hol_help. */
928 struct hol_help_state
930 /* PREV_ENTRY should contain the previous entry printed, or 0. */
931 struct hol_entry *prev_entry;
933 /* If an entry is in a different group from the previous one, and SEP_GROUPS
934 is true, then a blank line will be printed before any output. */
937 /* True if a duplicate option argument was suppressed (only ever set if
938 UPARAMS.dup_args is false). */
939 int suppressed_dup_arg;
942 /* Some state used while printing a help entry (used to communicate with
943 helper functions). See the doc for hol_entry_help for more info, as most
944 of the fields are copied from its arguments. */
947 const struct hol_entry *entry;
948 argp_fmtstream_t stream;
949 struct hol_help_state *hhstate;
951 /* True if nothing's been printed so far. */
954 /* If non-zero, the state that was used to print this help. */
955 const struct argp_state *state;
958 /* If a user doc filter should be applied to DOC, do so. */
960 filter_doc (const char *doc, int key, const struct argp *argp,
961 const struct argp_state *state)
963 if (argp->help_filter)
964 /* We must apply a user filter to this output. */
966 void *input = __argp_input (argp, state);
967 return (*argp->help_filter) (key, doc, input);
974 /* Prints STR as a header line, with the margin lines set appropiately, and
975 notes the fact that groups should be separated with a blank line. ARGP is
976 the argp that should dictate any user doc filtering to take place. Note
977 that the previous wrap margin isn't restored, but the left margin is reset
980 print_header (const char *str, const struct argp *argp,
981 struct pentry_state *pest)
983 const char *tstr = dgettext (argp->argp_domain, str);
984 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
990 if (pest->hhstate->prev_entry)
991 /* Precede with a blank line. */
992 __argp_fmtstream_putc (pest->stream, '\n');
993 indent_to (pest->stream, uparams.header_col);
994 __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
995 __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
996 __argp_fmtstream_puts (pest->stream, fstr);
997 __argp_fmtstream_set_lmargin (pest->stream, 0);
998 __argp_fmtstream_putc (pest->stream, '\n');
1001 pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
1005 free ((char *) fstr);
1008 /* Inserts a comma if this isn't the first item on the line, and then makes
1009 sure we're at least to column COL. If this *is* the first item on a line,
1010 prints any pending whitespace/headers that should precede this line. Also
1013 comma (unsigned col, struct pentry_state *pest)
1017 const struct hol_entry *pe = pest->hhstate->prev_entry;
1018 const struct hol_cluster *cl = pest->entry->cluster;
1020 if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
1021 __argp_fmtstream_putc (pest->stream, '\n');
1023 if (cl && cl->header && *cl->header
1025 || (pe->cluster != cl
1026 && !hol_cluster_is_child (pe->cluster, cl))))
1027 /* If we're changing clusters, then this must be the start of the
1028 ENTRY's cluster unless that is an ancestor of the previous one
1029 (in which case we had just popped into a sub-cluster for a bit).
1030 If so, then print the cluster's header line. */
1032 int old_wm = __argp_fmtstream_wmargin (pest->stream);
1033 print_header (cl->header, cl->argp, pest);
1034 __argp_fmtstream_set_wmargin (pest->stream, old_wm);
1040 __argp_fmtstream_puts (pest->stream, ", ");
1042 indent_to (pest->stream, col);
1045 /* Print help for ENTRY to STREAM. */
1047 hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
1048 argp_fmtstream_t stream, struct hol_help_state *hhstate)
1051 const struct argp_option *real = entry->opt, *opt;
1052 char *so = entry->short_options;
1053 int have_long_opt = 0; /* We have any long options. */
1054 /* Saved margins. */
1055 int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
1056 int old_wm = __argp_fmtstream_wmargin (stream);
1057 /* PEST is a state block holding some of our variables that we'd like to
1058 share with helper functions. */
1059 struct pentry_state pest;
1062 pest.stream = stream;
1063 pest.hhstate = hhstate;
1068 for (opt = real, num = entry->num; num > 0; opt++, num--)
1069 if (opt->name && ovisible (opt))
1075 /* First emit short options. */
1076 __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
1077 for (opt = real, num = entry->num; num > 0; opt++, num--)
1078 if (oshort (opt) && opt->key == *so)
1079 /* OPT has a valid (non shadowed) short option. */
1083 comma (uparams.short_opt_col, &pest);
1084 __argp_fmtstream_putc (stream, '-');
1085 __argp_fmtstream_putc (stream, *so);
1086 if (!have_long_opt || uparams.dup_args)
1087 arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
1089 hhstate->suppressed_dup_arg = 1;
1094 /* Now, long options. */
1096 /* A `documentation' option. */
1098 __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
1099 for (opt = real, num = entry->num; num > 0; opt++, num--)
1100 if (opt->name && *opt->name && ovisible (opt))
1102 comma (uparams.doc_opt_col, &pest);
1103 /* Calling dgettext here isn't quite right, since sorting will
1104 have been done on the original; but documentation options
1105 should be pretty rare anyway... */
1106 __argp_fmtstream_puts (stream,
1109 dgettext (state->root_argp->argp_domain,
1114 /* A real long option. */
1116 int first_long_opt = 1;
1118 __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
1119 for (opt = real, num = entry->num; num > 0; opt++, num--)
1120 if (opt->name && ovisible (opt))
1122 comma (uparams.long_opt_col, &pest);
1123 __argp_fmtstream_printf (stream, "--%s", opt->name);
1124 if (first_long_opt || uparams.dup_args)
1125 arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
1128 hhstate->suppressed_dup_arg = 1;
1132 /* Next, documentation strings. */
1133 __argp_fmtstream_set_lmargin (stream, 0);
1137 /* Didn't print any switches, what's up? */
1138 if (!oshort (real) && !real->name)
1139 /* This is a group header, print it nicely. */
1140 print_header (real->doc, entry->argp, &pest);
1142 /* Just a totally shadowed option or null header; print nothing. */
1143 goto cleanup; /* Just return, after cleaning up. */
1147 const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
1149 const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
1152 unsigned int col = __argp_fmtstream_point (stream);
1154 __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
1155 __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
1157 if (col > (unsigned int) (uparams.opt_doc_col + 3))
1158 __argp_fmtstream_putc (stream, '\n');
1159 else if (col >= (unsigned int) uparams.opt_doc_col)
1160 __argp_fmtstream_puts (stream, " ");
1162 indent_to (stream, uparams.opt_doc_col);
1164 __argp_fmtstream_puts (stream, fstr);
1166 if (fstr && fstr != tstr)
1167 free ((char *) fstr);
1169 /* Reset the left margin. */
1170 __argp_fmtstream_set_lmargin (stream, 0);
1171 __argp_fmtstream_putc (stream, '\n');
1174 hhstate->prev_entry = entry;
1177 __argp_fmtstream_set_lmargin (stream, old_lm);
1178 __argp_fmtstream_set_wmargin (stream, old_wm);
1181 /* Output a long help message about the options in HOL to STREAM. */
1183 hol_help (struct hol *hol, const struct argp_state *state,
1184 argp_fmtstream_t stream)
1187 struct hol_entry *entry;
1188 struct hol_help_state hhstate = { 0, 0, 0 };
1190 for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
1191 hol_entry_help (entry, state, stream, &hhstate);
1193 if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
1195 const char *tstr = dgettext (state->root_argp->argp_domain, "\
1196 Mandatory or optional arguments to long options are also mandatory or \
1197 optional for any corresponding short options.");
1198 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
1199 state ? state->root_argp : 0, state);
1202 __argp_fmtstream_putc (stream, '\n');
1203 __argp_fmtstream_puts (stream, fstr);
1204 __argp_fmtstream_putc (stream, '\n');
1206 if (fstr && fstr != tstr)
1207 free ((char *) fstr);
1211 /* Helper functions for hol_usage. */
1213 /* If OPT is a short option without an arg, append its key to the string
1214 pointer pointer to by COOKIE, and advance the pointer. */
1216 add_argless_short_opt (const struct argp_option *opt,
1217 const struct argp_option *real,
1218 const char *domain, void *cookie)
1220 char **snao_end = cookie;
1221 if (!(opt->arg || real->arg)
1222 && !((opt->flags | real->flags) & OPTION_NO_USAGE))
1223 *(*snao_end)++ = opt->key;
1227 /* If OPT is a short option with an arg, output a usage entry for it to the
1228 stream pointed at by COOKIE. */
1230 usage_argful_short_opt (const struct argp_option *opt,
1231 const struct argp_option *real,
1232 const char *domain, void *cookie)
1234 argp_fmtstream_t stream = cookie;
1235 const char *arg = opt->arg;
1236 int flags = opt->flags | real->flags;
1241 if (arg && !(flags & OPTION_NO_USAGE))
1243 arg = dgettext (domain, arg);
1245 if (flags & OPTION_ARG_OPTIONAL)
1246 __argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
1249 /* Manually do line wrapping so that it (probably) won't
1250 get wrapped at the embedded space. */
1251 space (stream, 6 + strlen (arg));
1252 __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
1259 /* Output a usage entry for the long option opt to the stream pointed at by
1262 usage_long_opt (const struct argp_option *opt,
1263 const struct argp_option *real,
1264 const char *domain, void *cookie)
1266 argp_fmtstream_t stream = cookie;
1267 const char *arg = opt->arg;
1268 int flags = opt->flags | real->flags;
1273 if (! (flags & OPTION_NO_USAGE))
1277 arg = dgettext (domain, arg);
1278 if (flags & OPTION_ARG_OPTIONAL)
1279 __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
1281 __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
1284 __argp_fmtstream_printf (stream, " [--%s]", opt->name);
1290 /* Print a short usage description for the arguments in HOL to STREAM. */
1292 hol_usage (struct hol *hol, argp_fmtstream_t stream)
1294 if (hol->num_entries > 0)
1297 struct hol_entry *entry;
1298 char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
1299 char *snao_end = short_no_arg_opts;
1301 /* First we put a list of short options without arguments. */
1302 for (entry = hol->entries, nentries = hol->num_entries
1304 ; entry++, nentries--)
1305 hol_entry_short_iterate (entry, add_argless_short_opt,
1306 entry->argp->argp_domain, &snao_end);
1307 if (snao_end > short_no_arg_opts)
1310 __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
1313 /* Now a list of short options *with* arguments. */
1314 for (entry = hol->entries, nentries = hol->num_entries
1316 ; entry++, nentries--)
1317 hol_entry_short_iterate (entry, usage_argful_short_opt,
1318 entry->argp->argp_domain, stream);
1320 /* Finally, a list of long options (whew!). */
1321 for (entry = hol->entries, nentries = hol->num_entries
1323 ; entry++, nentries--)
1324 hol_entry_long_iterate (entry, usage_long_opt,
1325 entry->argp->argp_domain, stream);
1329 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1330 cluster in which ARGP's entries should be clustered, or 0. */
1332 argp_hol (const struct argp *argp, struct hol_cluster *cluster)
1334 const struct argp_child *child = argp->children;
1335 struct hol *hol = make_hol (argp, cluster);
1339 struct hol_cluster *child_cluster =
1340 ((child->group || child->header)
1341 /* Put CHILD->argp within its own cluster. */
1342 ? hol_add_cluster (hol, child->group, child->header,
1343 child - argp->children, cluster, argp)
1344 /* Just merge it into the parent's cluster. */
1346 hol_append (hol, argp_hol (child->argp, child_cluster)) ;
1352 /* Calculate how many different levels with alternative args strings exist in
1355 argp_args_levels (const struct argp *argp)
1358 const struct argp_child *child = argp->children;
1360 if (argp->args_doc && strchr (argp->args_doc, '\n'))
1365 levels += argp_args_levels ((child++)->argp);
1370 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1371 preceded by a space. LEVELS is a pointer to a byte vector the length
1372 returned by argp_args_levels; it should be initialized to zero, and
1373 updated by this routine for the next call if ADVANCE is true. True is
1374 returned as long as there are more patterns to output. */
1376 argp_args_usage (const struct argp *argp, const struct argp_state *state,
1377 char **levels, int advance, argp_fmtstream_t stream)
1379 char *our_level = *levels;
1381 const struct argp_child *child = argp->children;
1382 const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
1383 const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
1387 const char *cp = fdoc;
1388 nl = __strchrnul (cp, '\n');
1390 /* This is a `multi-level' args doc; advance to the correct position
1391 as determined by our state in LEVELS, and update LEVELS. */
1395 for (i = 0; i < *our_level; i++)
1396 cp = nl + 1, nl = __strchrnul (cp, '\n');
1400 /* Manually do line wrapping so that it (probably) won't get wrapped at
1401 any embedded spaces. */
1402 space (stream, 1 + nl - cp);
1404 __argp_fmtstream_write (stream, cp, nl - cp);
1406 if (fdoc && fdoc != tdoc)
1407 free ((char *)fdoc); /* Free user's modified doc string. */
1411 advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
1413 if (advance && multiple)
1415 /* Need to increment our level. */
1417 /* There's more we can do here. */
1420 advance = 0; /* Our parent shouldn't advance also. */
1422 else if (*our_level > 0)
1423 /* We had multiple levels, but used them up; reset to zero. */
1430 /* Print the documentation for ARGP to STREAM; if POST is false, then
1431 everything preceeding a `\v' character in the documentation strings (or
1432 the whole string, for those with none) is printed, otherwise, everything
1433 following the `\v' character (nothing for strings without). Each separate
1434 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1435 then the first is as well. If FIRST_ONLY is true, only the first
1436 occurrence is output. Returns true if anything was output. */
1438 argp_doc (const struct argp *argp, const struct argp_state *state,
1439 int post, int pre_blank, int first_only,
1440 argp_fmtstream_t stream)
1443 const char *inp_text;
1446 size_t inp_text_limit = 0;
1447 const char *doc = dgettext (argp->argp_domain, argp->doc);
1448 const struct argp_child *child = argp->children;
1452 char *vt = strchr (doc, '\v');
1453 inp_text = post ? (vt ? vt + 1 : 0) : doc;
1454 inp_text_limit = (!post && vt) ? (vt - doc) : 0;
1459 if (argp->help_filter)
1460 /* We have to filter the doc strings. */
1463 /* Copy INP_TEXT so that it's nul-terminated. */
1464 inp_text = __strndup (inp_text, inp_text_limit);
1465 input = __argp_input (argp, state);
1467 (*argp->help_filter) (post
1468 ? ARGP_KEY_HELP_POST_DOC
1469 : ARGP_KEY_HELP_PRE_DOC,
1473 text = (const char *) inp_text;
1478 __argp_fmtstream_putc (stream, '\n');
1480 if (text == inp_text && inp_text_limit)
1481 __argp_fmtstream_write (stream, inp_text, inp_text_limit);
1483 __argp_fmtstream_puts (stream, text);
1485 if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
1486 __argp_fmtstream_putc (stream, '\n');
1491 if (text && text != inp_text)
1492 free ((char *) text); /* Free TEXT returned from the help filter. */
1493 if (inp_text && inp_text_limit && argp->help_filter)
1494 free ((char *) inp_text); /* We copied INP_TEXT, so free it now. */
1496 if (post && argp->help_filter)
1497 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1499 text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
1502 if (anything || pre_blank)
1503 __argp_fmtstream_putc (stream, '\n');
1504 __argp_fmtstream_puts (stream, text);
1505 free ((char *) text);
1506 if (__argp_fmtstream_point (stream)
1507 > __argp_fmtstream_lmargin (stream))
1508 __argp_fmtstream_putc (stream, '\n');
1514 while (child->argp && !(first_only && anything))
1516 argp_doc ((child++)->argp, state,
1517 post, anything || pre_blank, first_only,
1523 /* Output a usage message for ARGP to STREAM. If called from
1524 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1525 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1528 _help (const struct argp *argp, const struct argp_state *state, FILE *stream,
1529 unsigned flags, char *name)
1531 int anything = 0; /* Whether we've output anything. */
1532 struct hol *hol = 0;
1533 argp_fmtstream_t fs;
1538 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1539 __flockfile (stream);
1542 if (! uparams.valid)
1543 fill_in_uparams (state);
1545 fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
1548 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1549 __funlockfile (stream);
1554 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
1556 hol = argp_hol (argp, 0);
1558 /* If present, these options always come last. */
1559 hol_set_group (hol, "help", -1);
1560 hol_set_group (hol, "version", -1);
1565 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
1566 /* Print a short `Usage:' message. */
1568 int first_pattern = 1, more_patterns;
1569 size_t num_pattern_levels = argp_args_levels (argp);
1570 char *pattern_levels = alloca (num_pattern_levels);
1572 memset (pattern_levels, 0, num_pattern_levels);
1577 int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
1578 char *levels = pattern_levels;
1581 __argp_fmtstream_printf (fs, "%s %s",
1582 dgettext (argp->argp_domain, "Usage:"),
1585 __argp_fmtstream_printf (fs, "%s %s",
1586 dgettext (argp->argp_domain, " or: "),
1589 /* We set the lmargin as well as the wmargin, because hol_usage
1590 manually wraps options with newline to avoid annoying breaks. */
1591 old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
1593 if (flags & ARGP_HELP_SHORT_USAGE)
1594 /* Just show where the options go. */
1596 if (hol->num_entries > 0)
1597 __argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
1601 /* Actually print the options. */
1603 hol_usage (hol, fs);
1604 flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once. */
1607 more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
1609 __argp_fmtstream_set_wmargin (fs, old_wm);
1610 __argp_fmtstream_set_lmargin (fs, old_lm);
1612 __argp_fmtstream_putc (fs, '\n');
1617 while (more_patterns);
1620 if (flags & ARGP_HELP_PRE_DOC)
1621 anything |= argp_doc (argp, state, 0, 0, 1, fs);
1623 if (flags & ARGP_HELP_SEE)
1625 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
1626 Try `%s --help' or `%s --usage' for more information.\n"),
1631 if (flags & ARGP_HELP_LONG)
1632 /* Print a long, detailed help message. */
1634 /* Print info about all the options. */
1635 if (hol->num_entries > 0)
1638 __argp_fmtstream_putc (fs, '\n');
1639 hol_help (hol, state, fs);
1644 if (flags & ARGP_HELP_POST_DOC)
1645 /* Print any documentation strings at the end. */
1646 anything |= argp_doc (argp, state, 1, anything, 0, fs);
1648 if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
1651 __argp_fmtstream_putc (fs, '\n');
1652 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
1653 "Report bugs to %s.\n"),
1654 argp_program_bug_address);
1658 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1659 __funlockfile (stream);
1665 __argp_fmtstream_free (fs);
1668 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1669 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1670 void __argp_help (const struct argp *argp, FILE *stream,
1671 unsigned flags, char *name)
1673 struct argp_state state;
1674 memset (&state, 0, sizeof state);
1675 state.root_argp = argp;
1676 _help (argp, &state, stream, flags, name);
1679 weak_alias (__argp_help, argp_help)
1683 __argp_base_name (char *name)
1686 for (p = name + strlen (name); p > name && !ISSLASH (p[-1]); p--)
1691 #if ! (defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME)
1693 __argp_short_program_name (void)
1695 # if HAVE_DECL_PROGRAM_INVOCATION_NAME
1696 return __argp_base_name (program_invocation_name);
1698 /* FIXME: What now? Miles suggests that it is better to use NULL,
1699 but currently the value is passed on directly to fputs_unlocked,
1700 so that requires more changes. */
1702 # warning No reasonable value to return
1703 # endif /* __GNUC__ */
1709 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1710 from the set ARGP_HELP_*. */
1712 __argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
1714 if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
1716 if (state && (state->flags & ARGP_LONG_ONLY))
1717 flags |= ARGP_HELP_LONG_ONLY;
1719 _help (state ? state->root_argp : 0, state, stream, flags,
1720 state ? state->name : __argp_short_program_name ());
1722 if (!state || ! (state->flags & ARGP_NO_EXIT))
1724 if (flags & ARGP_HELP_EXIT_ERR)
1725 exit (argp_err_exit_status);
1726 if (flags & ARGP_HELP_EXIT_OK)
1732 weak_alias (__argp_state_help, argp_state_help)
1735 /* If appropriate, print the printf string FMT and following args, preceded
1736 by the program name and `:', to stderr, and followed by a `Try ... --help'
1737 message, then exit (1). */
1739 __argp_error (const struct argp_state *state, const char *fmt, ...)
1741 if (!state || !(state->flags & ARGP_NO_ERRS))
1743 FILE *stream = state ? state->err_stream : stderr;
1749 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1750 __flockfile (stream);
1756 if (_IO_fwide (stream, 0) > 0)
1760 if (__asprintf (&buf, fmt, ap) < 0)
1763 __fwprintf (stream, L"%s: %s\n",
1764 state ? state->name : __argp_short_program_name (),
1772 fputs_unlocked (state
1773 ? state->name : __argp_short_program_name (),
1775 putc_unlocked (':', stream);
1776 putc_unlocked (' ', stream);
1778 vfprintf (stream, fmt, ap);
1780 putc_unlocked ('\n', stream);
1783 __argp_state_help (state, stream, ARGP_HELP_STD_ERR);
1787 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1788 __funlockfile (stream);
1794 weak_alias (__argp_error, argp_error)
1797 /* Similar to the standard gnu error-reporting function error(), but will
1798 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1799 to STATE->err_stream. This is useful for argument parsing code that is
1800 shared between program startup (when exiting is desired) and runtime
1801 option parsing (when typically an error code is returned instead). The
1802 difference between this function and argp_error is that the latter is for
1803 *parsing errors*, and the former is for other problems that occur during
1804 parsing but don't reflect a (syntactic) problem with the input. */
1806 __argp_failure (const struct argp_state *state, int status, int errnum,
1807 const char *fmt, ...)
1809 if (!state || !(state->flags & ARGP_NO_ERRS))
1811 FILE *stream = state ? state->err_stream : stderr;
1815 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1816 __flockfile (stream);
1820 if (_IO_fwide (stream, 0) > 0)
1821 __fwprintf (stream, L"%s",
1822 state ? state->name : __argp_short_program_name ());
1825 fputs_unlocked (state
1826 ? state->name : __argp_short_program_name (),
1835 if (_IO_fwide (stream, 0) > 0)
1839 if (__asprintf (&buf, fmt, ap) < 0)
1842 __fwprintf (stream, L": %s", buf);
1849 putc_unlocked (':', stream);
1850 putc_unlocked (' ', stream);
1852 vfprintf (stream, fmt, ap);
1863 if (_IO_fwide (stream, 0) > 0)
1864 __fwprintf (stream, L": %s",
1865 __strerror_r (errnum, buf, sizeof (buf)));
1869 char const *s = NULL;
1870 putc_unlocked (':', stream);
1871 putc_unlocked (' ', stream);
1872 #if _LIBC || (HAVE_DECL_STRERROR_R && STRERROR_R_CHAR_P)
1873 s = __strerror_r (errnum, buf, sizeof buf);
1874 #elif HAVE_DECL_STRERROR_R
1875 if (__strerror_r (errnum, buf, sizeof buf) == 0)
1879 if (! s && ! (s = strerror (errnum)))
1880 s = dgettext (state->root_argp->argp_domain,
1881 "Unknown system error");
1888 if (_IO_fwide (stream, 0) > 0)
1889 putwc_unlocked (L'\n', stream);
1892 putc_unlocked ('\n', stream);
1894 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1895 __funlockfile (stream);
1898 if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
1904 weak_alias (__argp_failure, argp_failure)