1 /* Hierarchial argument parsing help output
2 Copyright (C) 1995-2000, 2001, 2002, 2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 # define _GNU_SOURCE 1
30 # define alloca __builtin_alloca
31 # define HAVE_ALLOCA 1
33 # if defined HAVE_ALLOCA_H || defined _LIBC
58 /* This is for other GNU distributions with internationalized messages. */
59 # if defined HAVE_LIBINTL_H || defined _LIBC
63 # define dgettext(domain, msgid) \
64 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
67 # define dgettext(domain, msgid) (msgid)
73 # if !HAVE_DECL_STRERROR_R
74 char *strerror_r (int errnum, char *buf, size_t buflen);
77 # if !HAVE_DECL_STRERROR
78 char *strerror (int errnum);
84 #include "argp-fmtstream.h"
85 #include "argp-namefrob.h"
88 # define SIZE_MAX ((size_t) -1)
91 /* User-selectable (using an environment variable) formatting parameters.
93 These may be specified in an environment variable called `ARGP_HELP_FMT',
94 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
95 Where VALn must be a positive integer. The list of variables is in the
96 UPARAM_NAMES vector, below. */
98 /* Default parameters. */
99 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
100 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
101 #define SHORT_OPT_COL 2 /* column in which short options start */
102 #define LONG_OPT_COL 6 /* column in which long options start */
103 #define DOC_OPT_COL 2 /* column in which doc options start */
104 #define OPT_DOC_COL 29 /* column in which option text starts */
105 #define HEADER_COL 1 /* column in which group headers are printed */
106 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
107 #define RMARGIN 79 /* right margin used for wrapping */
109 /* User-selectable (using an environment variable) formatting parameters.
110 They must all be of type `int' for the parsing code to work. */
113 /* If true, arguments for an option are shown with both short and long
114 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
115 If false, then if an option has both, the argument is only shown with
116 the long one, e.g., `-x, --longx=ARG', and a message indicating that
117 this really means both is printed below the options. */
120 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
121 been suppressed, an explanatory message should be printed. */
124 /* Various output columns. */
133 int valid; /* True when the values in here are valid. */
136 /* This is a global variable, as user options are only ever read once. */
137 static struct uparams uparams = {
138 DUP_ARGS, DUP_ARGS_NOTE,
139 SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,
140 USAGE_INDENT, RMARGIN,
144 /* A particular uparam, and what the user name is. */
147 const char *name; /* User name. */
148 int is_bool; /* Whether it's `boolean'. */
149 size_t uparams_offs; /* Location of the (int) field in UPARAMS. */
152 /* The name-field mappings we know about. */
153 static const struct uparam_name uparam_names[] =
155 { "dup-args", 1, offsetof (struct uparams, dup_args) },
156 { "dup-args-note", 1, offsetof (struct uparams, dup_args_note) },
157 { "short-opt-col", 0, offsetof (struct uparams, short_opt_col) },
158 { "long-opt-col", 0, offsetof (struct uparams, long_opt_col) },
159 { "doc-opt-col", 0, offsetof (struct uparams, doc_opt_col) },
160 { "opt-doc-col", 0, offsetof (struct uparams, opt_doc_col) },
161 { "header-col", 0, offsetof (struct uparams, header_col) },
162 { "usage-indent", 0, offsetof (struct uparams, usage_indent) },
163 { "rmargin", 0, offsetof (struct uparams, rmargin) },
167 /* Read user options from the environment, and fill in UPARAMS appropiately. */
169 fill_in_uparams (const struct argp_state *state)
171 const char *var = getenv ("ARGP_HELP_FMT");
173 #define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
184 const struct uparam_name *un;
185 int unspec = 0, val = 0;
186 const char *arg = var;
188 while (isalnum (*arg) || *arg == '-' || *arg == '_')
194 if (*arg == '\0' || *arg == ',')
196 else if (*arg == '=')
204 if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')
213 else if (isdigit (*arg))
216 while (isdigit (*arg))
221 for (un = uparam_names; un->name; un++)
222 if (strlen (un->name) == var_len
223 && strncmp (var, un->name, var_len) == 0)
225 if (unspec && !un->is_bool)
226 __argp_failure (state, 0, 0,
227 dgettext (state->root_argp->argp_domain, "\
228 %.*s: ARGP_HELP_FMT parameter requires a value"),
231 *(int *)((char *)&uparams + un->uparams_offs) = val;
235 __argp_failure (state, 0, 0,
236 dgettext (state->root_argp->argp_domain, "\
237 %.*s: Unknown ARGP_HELP_FMT parameter"),
246 __argp_failure (state, 0, 0,
247 dgettext (state->root_argp->argp_domain,
248 "Garbage in ARGP_HELP_FMT: %s"), var);
254 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
255 whether OPT is displayed or used in sorting, not option shadowing. */
256 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
258 /* Returns true if OPT is an alias for an earlier option. */
259 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
261 /* Returns true if OPT is an documentation-only entry. */
262 #define odoc(opt) ((opt)->flags & OPTION_DOC)
264 /* Returns true if OPT is the end-of-list marker for a list of options. */
265 #define oend(opt) __option_is_end (opt)
267 /* Returns true if OPT has a short option. */
268 #define oshort(opt) __option_is_short (opt)
271 The help format for a particular option is like:
273 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
275 Where ARG will be omitted if there's no argument, for this option, or
276 will be surrounded by "[" and "]" appropiately if the argument is
277 optional. The documentation string is word-wrapped appropiately, and if
278 the list of options is long enough, it will be started on a separate line.
279 If there are no short options for a given option, the first long option is
280 indented slighly in a way that's supposed to make most long options appear
281 to be in a separate column.
283 For example, the following output (from ps):
285 -p PID, --pid=PID List the process PID
286 --pgrp=PGRP List processes in the process group PGRP
287 -P, -x, --no-parent Include processes without parents
288 -Q, --all-fields Don't elide unusable fields (normally if there's
289 some reason ps can't print a field for any
290 process, it's removed from the output entirely)
291 -r, --reverse, --gratuitously-long-reverse-option
292 Reverse the order of any sort
293 --session[=SID] Add the processes from the session SID (which
294 defaults to the sid of the current process)
296 Here are some more options:
297 -f ZOT, --foonly=ZOT Glork a foonly
298 -z, --zaza Snit a zar
300 -?, --help Give this help list
301 --usage Give a short usage message
302 -V, --version Print program version
304 The struct argp_option array for the above could look like:
307 {"pid", 'p', "PID", 0, "List the process PID"},
308 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
309 {"no-parent", 'P', 0, 0, "Include processes without parents"},
310 {0, 'x', 0, OPTION_ALIAS},
311 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
312 " if there's some reason ps can't"
313 " print a field for any process, it's"
314 " removed from the output entirely)" },
315 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
316 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
317 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
318 "Add the processes from the session"
319 " SID (which defaults to the sid of"
320 " the current process)" },
322 {0,0,0,0, "Here are some more options:"},
323 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
324 {"zaza", 'z', 0, 0, "Snit a zar"},
329 Note that the last three options are automatically supplied by argp_parse,
330 unless you tell it not to with ARGP_NO_HELP.
334 /* Returns true if CH occurs between BEG and END. */
336 find_char (char ch, char *beg, char *end)
346 struct hol_cluster; /* fwd decl */
351 const struct argp_option *opt;
352 /* Number of options (including aliases). */
355 /* A pointers into the HOL's short_options field, to the first short option
356 letter for this entry. The order of the characters following this point
357 corresponds to the order of options pointed to by OPT, and there are at
358 most NUM. A short option recorded in a option following OPT is only
359 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
360 probably been shadowed by some other entry). */
363 /* Entries are sorted by their group first, in the order:
364 1, 2, ..., n, 0, -m, ..., -2, -1
365 and then alphabetically within each group. The default is 0. */
368 /* The cluster of options this entry belongs to, or 0 if none. */
369 struct hol_cluster *cluster;
371 /* The argp from which this option came. */
372 const struct argp *argp;
375 /* A cluster of entries to reflect the argp tree structure. */
378 /* A descriptive header printed before options in this cluster. */
381 /* Used to order clusters within the same group with the same parent,
382 according to the order in which they occurred in the parent argp's child
386 /* How to sort this cluster with respect to options and other clusters at the
387 same depth (clusters always follow options in the same group). */
390 /* The cluster to which this cluster belongs, or 0 if it's at the base
392 struct hol_cluster *parent;
394 /* The argp from which this cluster is (eventually) derived. */
395 const struct argp *argp;
397 /* The distance this cluster is from the root. */
400 /* Clusters in a given hol are kept in a linked list, to make freeing them
402 struct hol_cluster *next;
405 /* A list of options for help. */
408 /* An array of hol_entry's. */
409 struct hol_entry *entries;
410 /* The number of entries in this hol. If this field is zero, the others
412 unsigned num_entries;
414 /* A string containing all short options in this HOL. Each entry contains
415 pointers into this string, so the order can't be messed with blindly. */
418 /* Clusters of entries in this hol. */
419 struct hol_cluster *clusters;
422 /* Create a struct hol from the options in ARGP. CLUSTER is the
423 hol_cluster in which these entries occur, or 0, if at the root. */
425 make_hol (const struct argp *argp, struct hol_cluster *cluster)
428 const struct argp_option *o;
429 const struct argp_option *opts = argp->options;
430 struct hol_entry *entry;
431 unsigned num_short_options = 0;
432 struct hol *hol = malloc (sizeof (struct hol));
436 hol->num_entries = 0;
443 /* The first option must not be an alias. */
444 assert (! oalias (opts));
446 /* Calculate the space needed. */
447 for (o = opts; ! oend (o); o++)
452 num_short_options++; /* This is an upper bound. */
455 hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);
456 hol->short_options = malloc (num_short_options + 1);
458 assert (hol->entries && hol->short_options
459 && hol->num_entries <= SIZE_MAX / sizeof (struct hol_entry));
461 /* Fill in the entries. */
462 so = hol->short_options;
463 for (o = opts, entry = hol->entries; ! oend (o); entry++)
467 entry->short_options = so;
468 entry->group = cur_group =
471 : ((!o->name && !o->key)
474 entry->cluster = cluster;
480 if (oshort (o) && ! find_char (o->key, hol->short_options, so))
481 /* O has a valid short option which hasn't already been used.*/
485 while (! oend (o) && oalias (o));
487 *so = '\0'; /* null terminated so we can find the length */
493 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
494 associated argp child list entry), INDEX, and PARENT, and return a pointer
495 to it. ARGP is the argp that this cluster results from. */
496 static struct hol_cluster *
497 hol_add_cluster (struct hol *hol, int group, const char *header, int index,
498 struct hol_cluster *parent, const struct argp *argp)
500 struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));
509 cl->depth = parent ? parent->depth + 1 : 0;
511 cl->next = hol->clusters;
517 /* Free HOL and any resources it uses. */
519 hol_free (struct hol *hol)
521 struct hol_cluster *cl = hol->clusters;
525 struct hol_cluster *next = cl->next;
530 if (hol->num_entries > 0)
533 free (hol->short_options);
540 hol_entry_short_iterate (const struct hol_entry *entry,
541 int (*func)(const struct argp_option *opt,
542 const struct argp_option *real,
543 const char *domain, void *cookie),
544 const char *domain, void *cookie)
548 const struct argp_option *opt, *real = entry->opt;
549 char *so = entry->short_options;
551 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
552 if (oshort (opt) && *so == opt->key)
557 val = (*func)(opt, real, domain, cookie);
565 __attribute__ ((always_inline))
566 hol_entry_long_iterate (const struct hol_entry *entry,
567 int (*func)(const struct argp_option *opt,
568 const struct argp_option *real,
569 const char *domain, void *cookie),
570 const char *domain, void *cookie)
574 const struct argp_option *opt, *real = entry->opt;
576 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
582 val = (*func)(opt, real, domain, cookie);
588 /* Iterator that returns true for the first short option. */
590 until_short (const struct argp_option *opt, const struct argp_option *real,
591 const char *domain, void *cookie)
593 return oshort (opt) ? opt->key : 0;
596 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
598 hol_entry_first_short (const struct hol_entry *entry)
600 return hol_entry_short_iterate (entry, until_short,
601 entry->argp->argp_domain, 0);
604 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
606 hol_entry_first_long (const struct hol_entry *entry)
608 const struct argp_option *opt;
610 for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
611 if (opt->name && ovisible (opt))
616 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
618 static struct hol_entry *
619 hol_find_entry (struct hol *hol, const char *name)
621 struct hol_entry *entry = hol->entries;
622 unsigned num_entries = hol->num_entries;
624 while (num_entries-- > 0)
626 const struct argp_option *opt = entry->opt;
627 unsigned num_opts = entry->num;
629 while (num_opts-- > 0)
630 if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
641 /* If an entry with the long option NAME occurs in HOL, set it's special
642 sort position to GROUP. */
644 hol_set_group (struct hol *hol, const char *name, int group)
646 struct hol_entry *entry = hol_find_entry (hol, name);
648 entry->group = group;
651 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
652 EQ is what to return if GROUP1 and GROUP2 are the same. */
654 group_cmp (int group1, int group2, int eq)
656 if (group1 == group2)
658 else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
659 return group1 - group2;
661 return group2 - group1;
664 /* Compare clusters CL1 & CL2 by the order that they should appear in
667 hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
669 /* If one cluster is deeper than the other, use its ancestor at the same
670 level, so that finding the common ancestor is straightforward. */
671 while (cl1->depth < cl2->depth)
673 while (cl2->depth < cl1->depth)
676 /* Now reduce both clusters to their ancestors at the point where both have
677 a common parent; these can be directly compared. */
678 while (cl1->parent != cl2->parent)
679 cl1 = cl1->parent, cl2 = cl2->parent;
681 return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
684 /* Return the ancestor of CL that's just below the root (i.e., has a parent
686 static struct hol_cluster *
687 hol_cluster_base (struct hol_cluster *cl)
694 /* Return true if CL1 is a child of CL2. */
696 hol_cluster_is_child (const struct hol_cluster *cl1,
697 const struct hol_cluster *cl2)
699 while (cl1 && cl1 != cl2)
704 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
705 that should be used for comparisons, and returns true iff it should be
706 treated as a non-option. */
708 canon_doc_option (const char **name)
711 /* Skip initial whitespace. */
712 while (isspace (**name))
714 /* Decide whether this looks like an option (leading `-') or not. */
715 non_opt = (**name != '-');
716 /* Skip until part of name used for sorting. */
717 while (**name && !isalnum (**name))
722 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
725 hol_entry_cmp (const struct hol_entry *entry1,
726 const struct hol_entry *entry2)
728 /* The group numbers by which the entries should be ordered; if either is
729 in a cluster, then this is just the group within the cluster. */
730 int group1 = entry1->group, group2 = entry2->group;
732 if (entry1->cluster != entry2->cluster)
734 /* The entries are not within the same cluster, so we can't compare them
735 directly, we have to use the appropiate clustering level too. */
736 if (! entry1->cluster)
737 /* ENTRY1 is at the `base level', not in a cluster, so we have to
738 compare it's group number with that of the base cluster in which
739 ENTRY2 resides. Note that if they're in the same group, the
740 clustered option always comes laster. */
741 return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
742 else if (! entry2->cluster)
743 /* Likewise, but ENTRY2's not in a cluster. */
744 return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
746 /* Both entries are in clusters, we can just compare the clusters. */
747 return hol_cluster_cmp (entry1->cluster, entry2->cluster);
749 else if (group1 == group2)
750 /* The entries are both in the same cluster and group, so compare them
753 int short1 = hol_entry_first_short (entry1);
754 int short2 = hol_entry_first_short (entry2);
755 int doc1 = odoc (entry1->opt);
756 int doc2 = odoc (entry2->opt);
757 const char *long1 = hol_entry_first_long (entry1);
758 const char *long2 = hol_entry_first_long (entry2);
761 doc1 = canon_doc_option (&long1);
763 doc2 = canon_doc_option (&long2);
766 /* `documentation' options always follow normal options (or
767 documentation options that *look* like normal options). */
769 else if (!short1 && !short2 && long1 && long2)
770 /* Only long options. */
771 return __strcasecmp (long1, long2);
773 /* Compare short/short, long/short, short/long, using the first
774 character of long options. Entries without *any* valid
775 options (such as options with OPTION_HIDDEN set) will be put
776 first, but as they're not displayed, it doesn't matter where
779 char first1 = short1 ? short1 : long1 ? *long1 : 0;
780 char first2 = short2 ? short2 : long2 ? *long2 : 0;
782 int lower_cmp = _tolower (first1) - _tolower (first2);
784 int lower_cmp = tolower (first1) - tolower (first2);
786 /* Compare ignoring case, except when the options are both the
787 same letter, in which case lower-case always comes first. */
788 return lower_cmp ? lower_cmp : first2 - first1;
792 /* Within the same cluster, but not the same group, so just compare
794 return group_cmp (group1, group2, 0);
797 /* Version of hol_entry_cmp with correct signature for qsort. */
799 hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
801 return hol_entry_cmp (entry1_v, entry2_v);
804 /* Sort HOL by group and alphabetically by option name (with short options
805 taking precedence over long). Since the sorting is for display purposes
806 only, the shadowing of options isn't effected. */
808 hol_sort (struct hol *hol)
810 if (hol->num_entries > 0)
811 qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
815 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
816 any in MORE with the same name. */
818 hol_append (struct hol *hol, struct hol *more)
820 struct hol_cluster **cl_end = &hol->clusters;
822 /* Steal MORE's cluster list, and add it to the end of HOL's. */
824 cl_end = &(*cl_end)->next;
825 *cl_end = more->clusters;
829 if (more->num_entries > 0)
831 if (hol->num_entries == 0)
833 hol->num_entries = more->num_entries;
834 hol->entries = more->entries;
835 hol->short_options = more->short_options;
836 more->num_entries = 0; /* Mark MORE's fields as invalid. */
839 /* Append the entries in MORE to those in HOL, taking care to only add
840 non-shadowed SHORT_OPTIONS values. */
845 unsigned num_entries = hol->num_entries + more->num_entries;
846 struct hol_entry *entries =
847 malloc (num_entries * sizeof (struct hol_entry));
848 unsigned hol_so_len = strlen (hol->short_options);
849 char *short_options =
850 malloc (hol_so_len + strlen (more->short_options) + 1);
852 assert (entries && short_options
853 && num_entries <= SIZE_MAX / sizeof (struct hol_entry));
855 __mempcpy (__mempcpy (entries, hol->entries,
856 hol->num_entries * sizeof (struct hol_entry)),
858 more->num_entries * sizeof (struct hol_entry));
860 __mempcpy (short_options, hol->short_options, hol_so_len);
862 /* Fix up the short options pointers from HOL. */
863 for (e = entries, left = hol->num_entries; left > 0; e++, left--)
864 e->short_options += (short_options - hol->short_options);
866 /* Now add the short options from MORE, fixing up its entries
868 so = short_options + hol_so_len;
869 more_so = more->short_options;
870 for (left = more->num_entries; left > 0; e++, left--)
873 const struct argp_option *opt;
875 e->short_options = so;
877 for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
880 if (oshort (opt) && ch == opt->key)
881 /* The next short option in MORE_SO, CH, is from OPT. */
883 if (! find_char (ch, short_options,
884 short_options + hol_so_len))
885 /* The short option CH isn't shadowed by HOL's options,
886 so add it to the sum. */
896 free (hol->short_options);
898 hol->entries = entries;
899 hol->num_entries = num_entries;
900 hol->short_options = short_options;
907 /* Inserts enough spaces to make sure STREAM is at column COL. */
909 indent_to (argp_fmtstream_t stream, unsigned col)
911 int needed = col - __argp_fmtstream_point (stream);
913 __argp_fmtstream_putc (stream, ' ');
916 /* Output to STREAM either a space, or a newline if there isn't room for at
917 least ENSURE characters before the right margin. */
919 space (argp_fmtstream_t stream, size_t ensure)
921 if (__argp_fmtstream_point (stream) + ensure
922 >= __argp_fmtstream_rmargin (stream))
923 __argp_fmtstream_putc (stream, '\n');
925 __argp_fmtstream_putc (stream, ' ');
928 /* If the option REAL has an argument, we print it in using the printf
929 format REQ_FMT or OPT_FMT depending on whether it's a required or
930 optional argument. */
932 arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
933 const char *domain, argp_fmtstream_t stream)
937 if (real->flags & OPTION_ARG_OPTIONAL)
938 __argp_fmtstream_printf (stream, opt_fmt,
939 dgettext (domain, real->arg));
941 __argp_fmtstream_printf (stream, req_fmt,
942 dgettext (domain, real->arg));
946 /* Helper functions for hol_entry_help. */
948 /* State used during the execution of hol_help. */
949 struct hol_help_state
951 /* PREV_ENTRY should contain the previous entry printed, or 0. */
952 struct hol_entry *prev_entry;
954 /* If an entry is in a different group from the previous one, and SEP_GROUPS
955 is true, then a blank line will be printed before any output. */
958 /* True if a duplicate option argument was suppressed (only ever set if
959 UPARAMS.dup_args is false). */
960 int suppressed_dup_arg;
963 /* Some state used while printing a help entry (used to communicate with
964 helper functions). See the doc for hol_entry_help for more info, as most
965 of the fields are copied from its arguments. */
968 const struct hol_entry *entry;
969 argp_fmtstream_t stream;
970 struct hol_help_state *hhstate;
972 /* True if nothing's been printed so far. */
975 /* If non-zero, the state that was used to print this help. */
976 const struct argp_state *state;
979 /* If a user doc filter should be applied to DOC, do so. */
981 filter_doc (const char *doc, int key, const struct argp *argp,
982 const struct argp_state *state)
984 if (argp->help_filter)
985 /* We must apply a user filter to this output. */
987 void *input = __argp_input (argp, state);
988 return (*argp->help_filter) (key, doc, input);
995 /* Prints STR as a header line, with the margin lines set appropiately, and
996 notes the fact that groups should be separated with a blank line. ARGP is
997 the argp that should dictate any user doc filtering to take place. Note
998 that the previous wrap margin isn't restored, but the left margin is reset
1001 print_header (const char *str, const struct argp *argp,
1002 struct pentry_state *pest)
1004 const char *tstr = dgettext (argp->argp_domain, str);
1005 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
1011 if (pest->hhstate->prev_entry)
1012 /* Precede with a blank line. */
1013 __argp_fmtstream_putc (pest->stream, '\n');
1014 indent_to (pest->stream, uparams.header_col);
1015 __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
1016 __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
1017 __argp_fmtstream_puts (pest->stream, fstr);
1018 __argp_fmtstream_set_lmargin (pest->stream, 0);
1019 __argp_fmtstream_putc (pest->stream, '\n');
1022 pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
1026 free ((char *) fstr);
1029 /* Inserts a comma if this isn't the first item on the line, and then makes
1030 sure we're at least to column COL. If this *is* the first item on a line,
1031 prints any pending whitespace/headers that should precede this line. Also
1034 comma (unsigned col, struct pentry_state *pest)
1038 const struct hol_entry *pe = pest->hhstate->prev_entry;
1039 const struct hol_cluster *cl = pest->entry->cluster;
1041 if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
1042 __argp_fmtstream_putc (pest->stream, '\n');
1044 if (cl && cl->header && *cl->header
1046 || (pe->cluster != cl
1047 && !hol_cluster_is_child (pe->cluster, cl))))
1048 /* If we're changing clusters, then this must be the start of the
1049 ENTRY's cluster unless that is an ancestor of the previous one
1050 (in which case we had just popped into a sub-cluster for a bit).
1051 If so, then print the cluster's header line. */
1053 int old_wm = __argp_fmtstream_wmargin (pest->stream);
1054 print_header (cl->header, cl->argp, pest);
1055 __argp_fmtstream_set_wmargin (pest->stream, old_wm);
1061 __argp_fmtstream_puts (pest->stream, ", ");
1063 indent_to (pest->stream, col);
1066 /* Print help for ENTRY to STREAM. */
1068 hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
1069 argp_fmtstream_t stream, struct hol_help_state *hhstate)
1072 const struct argp_option *real = entry->opt, *opt;
1073 char *so = entry->short_options;
1074 int have_long_opt = 0; /* We have any long options. */
1075 /* Saved margins. */
1076 int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
1077 int old_wm = __argp_fmtstream_wmargin (stream);
1078 /* PEST is a state block holding some of our variables that we'd like to
1079 share with helper functions. */
1080 struct pentry_state pest = { entry, stream, hhstate, 1, state };
1083 for (opt = real, num = entry->num; num > 0; opt++, num--)
1084 if (opt->name && ovisible (opt))
1090 /* First emit short options. */
1091 __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
1092 for (opt = real, num = entry->num; num > 0; opt++, num--)
1093 if (oshort (opt) && opt->key == *so)
1094 /* OPT has a valid (non shadowed) short option. */
1098 comma (uparams.short_opt_col, &pest);
1099 __argp_fmtstream_putc (stream, '-');
1100 __argp_fmtstream_putc (stream, *so);
1101 if (!have_long_opt || uparams.dup_args)
1102 arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
1104 hhstate->suppressed_dup_arg = 1;
1109 /* Now, long options. */
1111 /* A `documentation' option. */
1113 __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
1114 for (opt = real, num = entry->num; num > 0; opt++, num--)
1115 if (opt->name && ovisible (opt))
1117 comma (uparams.doc_opt_col, &pest);
1118 /* Calling gettext here isn't quite right, since sorting will
1119 have been done on the original; but documentation options
1120 should be pretty rare anyway... */
1121 __argp_fmtstream_puts (stream,
1122 dgettext (state->root_argp->argp_domain,
1127 /* A real long option. */
1129 int first_long_opt = 1;
1131 __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
1132 for (opt = real, num = entry->num; num > 0; opt++, num--)
1133 if (opt->name && ovisible (opt))
1135 comma (uparams.long_opt_col, &pest);
1136 __argp_fmtstream_printf (stream, "--%s", opt->name);
1137 if (first_long_opt || uparams.dup_args)
1138 arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
1141 hhstate->suppressed_dup_arg = 1;
1145 /* Next, documentation strings. */
1146 __argp_fmtstream_set_lmargin (stream, 0);
1150 /* Didn't print any switches, what's up? */
1151 if (!oshort (real) && !real->name)
1152 /* This is a group header, print it nicely. */
1153 print_header (real->doc, entry->argp, &pest);
1155 /* Just a totally shadowed option or null header; print nothing. */
1156 goto cleanup; /* Just return, after cleaning up. */
1160 const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
1162 const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
1165 unsigned int col = __argp_fmtstream_point (stream);
1167 __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
1168 __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
1170 if (col > (unsigned int) (uparams.opt_doc_col + 3))
1171 __argp_fmtstream_putc (stream, '\n');
1172 else if (col >= (unsigned int) uparams.opt_doc_col)
1173 __argp_fmtstream_puts (stream, " ");
1175 indent_to (stream, uparams.opt_doc_col);
1177 __argp_fmtstream_puts (stream, fstr);
1179 if (fstr && fstr != tstr)
1180 free ((char *) fstr);
1182 /* Reset the left margin. */
1183 __argp_fmtstream_set_lmargin (stream, 0);
1184 __argp_fmtstream_putc (stream, '\n');
1187 hhstate->prev_entry = entry;
1190 __argp_fmtstream_set_lmargin (stream, old_lm);
1191 __argp_fmtstream_set_wmargin (stream, old_wm);
1194 /* Output a long help message about the options in HOL to STREAM. */
1196 hol_help (struct hol *hol, const struct argp_state *state,
1197 argp_fmtstream_t stream)
1200 struct hol_entry *entry;
1201 struct hol_help_state hhstate = { 0, 0, 0 };
1203 for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
1204 hol_entry_help (entry, state, stream, &hhstate);
1206 if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
1208 const char *tstr = dgettext (state->root_argp->argp_domain, "\
1209 Mandatory or optional arguments to long options are also mandatory or \
1210 optional for any corresponding short options.");
1211 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
1212 state ? state->root_argp : 0, state);
1215 __argp_fmtstream_putc (stream, '\n');
1216 __argp_fmtstream_puts (stream, fstr);
1217 __argp_fmtstream_putc (stream, '\n');
1219 if (fstr && fstr != tstr)
1220 free ((char *) fstr);
1224 /* Helper functions for hol_usage. */
1226 /* If OPT is a short option without an arg, append its key to the string
1227 pointer pointer to by COOKIE, and advance the pointer. */
1229 add_argless_short_opt (const struct argp_option *opt,
1230 const struct argp_option *real,
1231 const char *domain, void *cookie)
1233 char **snao_end = cookie;
1234 if (!(opt->arg || real->arg)
1235 && !((opt->flags | real->flags) & OPTION_NO_USAGE))
1236 *(*snao_end)++ = opt->key;
1240 /* If OPT is a short option with an arg, output a usage entry for it to the
1241 stream pointed at by COOKIE. */
1243 usage_argful_short_opt (const struct argp_option *opt,
1244 const struct argp_option *real,
1245 const char *domain, void *cookie)
1247 argp_fmtstream_t stream = cookie;
1248 const char *arg = opt->arg;
1249 int flags = opt->flags | real->flags;
1254 if (arg && !(flags & OPTION_NO_USAGE))
1256 arg = dgettext (domain, arg);
1258 if (flags & OPTION_ARG_OPTIONAL)
1259 __argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
1262 /* Manually do line wrapping so that it (probably) won't
1263 get wrapped at the embedded space. */
1264 space (stream, 6 + strlen (arg));
1265 __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
1272 /* Output a usage entry for the long option opt to the stream pointed at by
1275 usage_long_opt (const struct argp_option *opt,
1276 const struct argp_option *real,
1277 const char *domain, void *cookie)
1279 argp_fmtstream_t stream = cookie;
1280 const char *arg = opt->arg;
1281 int flags = opt->flags | real->flags;
1286 if (! (flags & OPTION_NO_USAGE))
1290 arg = dgettext (domain, arg);
1291 if (flags & OPTION_ARG_OPTIONAL)
1292 __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
1294 __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
1297 __argp_fmtstream_printf (stream, " [--%s]", opt->name);
1303 /* Print a short usage description for the arguments in HOL to STREAM. */
1305 hol_usage (struct hol *hol, argp_fmtstream_t stream)
1307 if (hol->num_entries > 0)
1310 struct hol_entry *entry;
1311 char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
1312 char *snao_end = short_no_arg_opts;
1314 /* First we put a list of short options without arguments. */
1315 for (entry = hol->entries, nentries = hol->num_entries
1317 ; entry++, nentries--)
1318 hol_entry_short_iterate (entry, add_argless_short_opt,
1319 entry->argp->argp_domain, &snao_end);
1320 if (snao_end > short_no_arg_opts)
1323 __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
1326 /* Now a list of short options *with* arguments. */
1327 for (entry = hol->entries, nentries = hol->num_entries
1329 ; entry++, nentries--)
1330 hol_entry_short_iterate (entry, usage_argful_short_opt,
1331 entry->argp->argp_domain, stream);
1333 /* Finally, a list of long options (whew!). */
1334 for (entry = hol->entries, nentries = hol->num_entries
1336 ; entry++, nentries--)
1337 hol_entry_long_iterate (entry, usage_long_opt,
1338 entry->argp->argp_domain, stream);
1342 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1343 cluster in which ARGP's entries should be clustered, or 0. */
1345 argp_hol (const struct argp *argp, struct hol_cluster *cluster)
1347 const struct argp_child *child = argp->children;
1348 struct hol *hol = make_hol (argp, cluster);
1352 struct hol_cluster *child_cluster =
1353 ((child->group || child->header)
1354 /* Put CHILD->argp within its own cluster. */
1355 ? hol_add_cluster (hol, child->group, child->header,
1356 child - argp->children, cluster, argp)
1357 /* Just merge it into the parent's cluster. */
1359 hol_append (hol, argp_hol (child->argp, child_cluster)) ;
1365 /* Calculate how many different levels with alternative args strings exist in
1368 argp_args_levels (const struct argp *argp)
1371 const struct argp_child *child = argp->children;
1373 if (argp->args_doc && strchr (argp->args_doc, '\n'))
1378 levels += argp_args_levels ((child++)->argp);
1383 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1384 preceded by a space. LEVELS is a pointer to a byte vector the length
1385 returned by argp_args_levels; it should be initialized to zero, and
1386 updated by this routine for the next call if ADVANCE is true. True is
1387 returned as long as there are more patterns to output. */
1389 argp_args_usage (const struct argp *argp, const struct argp_state *state,
1390 char **levels, int advance, argp_fmtstream_t stream)
1392 char *our_level = *levels;
1394 const struct argp_child *child = argp->children;
1395 const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
1396 const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
1400 const char *cp = fdoc;
1401 nl = __strchrnul (cp, '\n');
1403 /* This is a `multi-level' args doc; advance to the correct position
1404 as determined by our state in LEVELS, and update LEVELS. */
1408 for (i = 0; i < *our_level; i++)
1409 cp = nl + 1, nl = __strchrnul (cp, '\n');
1413 /* Manually do line wrapping so that it (probably) won't get wrapped at
1414 any embedded spaces. */
1415 space (stream, 1 + nl - cp);
1417 __argp_fmtstream_write (stream, cp, nl - cp);
1419 if (fdoc && fdoc != tdoc)
1420 free ((char *)fdoc); /* Free user's modified doc string. */
1424 advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
1426 if (advance && multiple)
1428 /* Need to increment our level. */
1430 /* There's more we can do here. */
1433 advance = 0; /* Our parent shouldn't advance also. */
1435 else if (*our_level > 0)
1436 /* We had multiple levels, but used them up; reset to zero. */
1443 /* Print the documentation for ARGP to STREAM; if POST is false, then
1444 everything preceeding a `\v' character in the documentation strings (or
1445 the whole string, for those with none) is printed, otherwise, everything
1446 following the `\v' character (nothing for strings without). Each separate
1447 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1448 then the first is as well. If FIRST_ONLY is true, only the first
1449 occurrence is output. Returns true if anything was output. */
1451 argp_doc (const struct argp *argp, const struct argp_state *state,
1452 int post, int pre_blank, int first_only,
1453 argp_fmtstream_t stream)
1456 const char *inp_text;
1459 size_t inp_text_limit = 0;
1460 const char *doc = dgettext (argp->argp_domain, argp->doc);
1461 const struct argp_child *child = argp->children;
1465 char *vt = strchr (doc, '\v');
1466 inp_text = post ? (vt ? vt + 1 : 0) : doc;
1467 inp_text_limit = (!post && vt) ? (vt - doc) : 0;
1472 if (argp->help_filter)
1473 /* We have to filter the doc strings. */
1476 /* Copy INP_TEXT so that it's nul-terminated. */
1477 inp_text = __strndup (inp_text, inp_text_limit);
1478 input = __argp_input (argp, state);
1480 (*argp->help_filter) (post
1481 ? ARGP_KEY_HELP_POST_DOC
1482 : ARGP_KEY_HELP_PRE_DOC,
1486 text = (const char *) inp_text;
1491 __argp_fmtstream_putc (stream, '\n');
1493 if (text == inp_text && inp_text_limit)
1494 __argp_fmtstream_write (stream, inp_text, inp_text_limit);
1496 __argp_fmtstream_puts (stream, text);
1498 if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
1499 __argp_fmtstream_putc (stream, '\n');
1504 if (text && text != inp_text)
1505 free ((char *) text); /* Free TEXT returned from the help filter. */
1506 if (inp_text && inp_text_limit && argp->help_filter)
1507 free ((char *) inp_text); /* We copied INP_TEXT, so free it now. */
1509 if (post && argp->help_filter)
1510 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1512 text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
1515 if (anything || pre_blank)
1516 __argp_fmtstream_putc (stream, '\n');
1517 __argp_fmtstream_puts (stream, text);
1518 free ((char *) text);
1519 if (__argp_fmtstream_point (stream)
1520 > __argp_fmtstream_lmargin (stream))
1521 __argp_fmtstream_putc (stream, '\n');
1527 while (child->argp && !(first_only && anything))
1529 argp_doc ((child++)->argp, state,
1530 post, anything || pre_blank, first_only,
1536 /* Output a usage message for ARGP to STREAM. If called from
1537 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1538 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1541 _help (const struct argp *argp, const struct argp_state *state, FILE *stream,
1542 unsigned flags, char *name)
1544 int anything = 0; /* Whether we've output anything. */
1545 struct hol *hol = 0;
1546 argp_fmtstream_t fs;
1551 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1552 __flockfile (stream);
1555 if (! uparams.valid)
1556 fill_in_uparams (state);
1558 fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
1561 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1562 __funlockfile (stream);
1567 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
1569 hol = argp_hol (argp, 0);
1571 /* If present, these options always come last. */
1572 hol_set_group (hol, "help", -1);
1573 hol_set_group (hol, "version", -1);
1578 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
1579 /* Print a short `Usage:' message. */
1581 int first_pattern = 1, more_patterns;
1582 size_t num_pattern_levels = argp_args_levels (argp);
1583 char *pattern_levels = alloca (num_pattern_levels);
1585 memset (pattern_levels, 0, num_pattern_levels);
1590 int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
1591 char *levels = pattern_levels;
1594 __argp_fmtstream_printf (fs, "%s %s",
1595 dgettext (argp->argp_domain, "Usage:"),
1598 __argp_fmtstream_printf (fs, "%s %s",
1599 dgettext (argp->argp_domain, " or: "),
1602 /* We set the lmargin as well as the wmargin, because hol_usage
1603 manually wraps options with newline to avoid annoying breaks. */
1604 old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
1606 if (flags & ARGP_HELP_SHORT_USAGE)
1607 /* Just show where the options go. */
1609 if (hol->num_entries > 0)
1610 __argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
1614 /* Actually print the options. */
1616 hol_usage (hol, fs);
1617 flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once. */
1620 more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
1622 __argp_fmtstream_set_wmargin (fs, old_wm);
1623 __argp_fmtstream_set_lmargin (fs, old_lm);
1625 __argp_fmtstream_putc (fs, '\n');
1630 while (more_patterns);
1633 if (flags & ARGP_HELP_PRE_DOC)
1634 anything |= argp_doc (argp, state, 0, 0, 1, fs);
1636 if (flags & ARGP_HELP_SEE)
1638 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
1639 Try `%s --help' or `%s --usage' for more information.\n"),
1644 if (flags & ARGP_HELP_LONG)
1645 /* Print a long, detailed help message. */
1647 /* Print info about all the options. */
1648 if (hol->num_entries > 0)
1651 __argp_fmtstream_putc (fs, '\n');
1652 hol_help (hol, state, fs);
1657 if (flags & ARGP_HELP_POST_DOC)
1658 /* Print any documentation strings at the end. */
1659 anything |= argp_doc (argp, state, 1, anything, 0, fs);
1661 if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
1664 __argp_fmtstream_putc (fs, '\n');
1665 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
1666 "Report bugs to %s.\n"),
1667 argp_program_bug_address);
1671 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1672 __funlockfile (stream);
1678 __argp_fmtstream_free (fs);
1681 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1682 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1683 void __argp_help (const struct argp *argp, FILE *stream,
1684 unsigned flags, char *name)
1686 _help (argp, 0, stream, flags, name);
1689 weak_alias (__argp_help, argp_help)
1693 char *__argp_basename (char *name)
1695 char *short_name = strrchr (name, '/');
1696 return short_name ? short_name + 1 : name;
1700 __argp_short_program_name (void)
1702 # if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
1703 return program_invocation_short_name;
1704 # elif HAVE_DECL_PROGRAM_INVOCATION_NAME
1705 return __argp_basename (program_invocation_name);
1707 /* FIXME: What now? Miles suggests that it is better to use NULL,
1708 but currently the value is passed on directly to fputs_unlocked,
1709 so that requires more changes. */
1711 # warning No reasonable value to return
1712 # endif /* __GNUC__ */
1718 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1719 from the set ARGP_HELP_*. */
1721 __argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
1723 if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
1725 if (state && (state->flags & ARGP_LONG_ONLY))
1726 flags |= ARGP_HELP_LONG_ONLY;
1728 _help (state ? state->root_argp : 0, state, stream, flags,
1729 state ? state->name : __argp_short_program_name ());
1731 if (!state || ! (state->flags & ARGP_NO_EXIT))
1733 if (flags & ARGP_HELP_EXIT_ERR)
1734 exit (argp_err_exit_status);
1735 if (flags & ARGP_HELP_EXIT_OK)
1741 weak_alias (__argp_state_help, argp_state_help)
1744 /* If appropriate, print the printf string FMT and following args, preceded
1745 by the program name and `:', to stderr, and followed by a `Try ... --help'
1746 message, then exit (1). */
1748 __argp_error (const struct argp_state *state, const char *fmt, ...)
1750 if (!state || !(state->flags & ARGP_NO_ERRS))
1752 FILE *stream = state ? state->err_stream : stderr;
1758 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1759 __flockfile (stream);
1765 if (_IO_fwide (stream, 0) > 0)
1769 __asprintf (&buf, fmt, ap);
1771 __fwprintf (stream, L"%s: %s\n",
1772 state ? state->name : __argp_short_program_name (),
1780 fputs_unlocked (state
1781 ? state->name : __argp_short_program_name (),
1783 putc_unlocked (':', stream);
1784 putc_unlocked (' ', stream);
1786 vfprintf (stream, fmt, ap);
1788 putc_unlocked ('\n', stream);
1791 __argp_state_help (state, stream, ARGP_HELP_STD_ERR);
1795 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1796 __funlockfile (stream);
1802 weak_alias (__argp_error, argp_error)
1805 /* Similar to the standard gnu error-reporting function error(), but will
1806 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1807 to STATE->err_stream. This is useful for argument parsing code that is
1808 shared between program startup (when exiting is desired) and runtime
1809 option parsing (when typically an error code is returned instead). The
1810 difference between this function and argp_error is that the latter is for
1811 *parsing errors*, and the former is for other problems that occur during
1812 parsing but don't reflect a (syntactic) problem with the input. */
1814 __argp_failure (const struct argp_state *state, int status, int errnum,
1815 const char *fmt, ...)
1817 if (!state || !(state->flags & ARGP_NO_ERRS))
1819 FILE *stream = state ? state->err_stream : stderr;
1823 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1824 __flockfile (stream);
1828 if (_IO_fwide (stream, 0) > 0)
1829 __fwprintf (stream, L"%s",
1830 state ? state->name : __argp_short_program_name ());
1833 fputs_unlocked (state
1834 ? state->name : __argp_short_program_name (),
1843 if (_IO_fwide (stream, 0) > 0)
1847 __asprintf (&buf, fmt, ap);
1849 __fwprintf (stream, L": %s", buf);
1856 putc_unlocked (':', stream);
1857 putc_unlocked (' ', stream);
1859 vfprintf (stream, fmt, ap);
1870 if (_IO_fwide (stream, 0) > 0)
1871 __fwprintf (stream, L": %s",
1872 __strerror_r (errnum, buf, sizeof (buf)));
1876 putc_unlocked (':', stream);
1877 putc_unlocked (' ', stream);
1878 #if defined _LIBC || defined HAVE_STRERROR_R
1879 fputs (__strerror_r (errnum, buf, sizeof (buf)), stream);
1881 fputs (strerror (errnum), stream);
1887 if (_IO_fwide (stream, 0) > 0)
1888 putwc_unlocked (L'\n', stream);
1891 putc_unlocked ('\n', stream);
1893 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1894 __funlockfile (stream);
1897 if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
1903 weak_alias (__argp_failure, argp_failure)