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
28 /* AIX requires this to be the first thing in the file. */
30 # if HAVE_ALLOCA_H || defined _LIBC
36 # ifndef alloca /* predefined by HP cc +Olibcalls */
54 /* This is for other GNU distributions with internationalized messages. */
55 # if defined HAVE_LIBINTL_H || defined _LIBC
59 # define dgettext(domain, msgid) \
60 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
63 # define dgettext(domain, msgid) (msgid)
69 # if !HAVE_DECL_STRERROR_R
70 char *strerror_r (int errnum, char *buf, size_t buflen);
73 # if !HAVE_DECL_STRERROR
74 char *strerror (int errnum);
80 #include "argp-fmtstream.h"
81 #include "argp-namefrob.h"
84 # define SIZE_MAX ((size_t) -1)
87 /* User-selectable (using an environment variable) formatting parameters.
89 These may be specified in an environment variable called `ARGP_HELP_FMT',
90 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
91 Where VALn must be a positive integer. The list of variables is in the
92 UPARAM_NAMES vector, below. */
94 /* Default parameters. */
95 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
96 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
97 #define SHORT_OPT_COL 2 /* column in which short options start */
98 #define LONG_OPT_COL 6 /* column in which long options start */
99 #define DOC_OPT_COL 2 /* column in which doc options start */
100 #define OPT_DOC_COL 29 /* column in which option text starts */
101 #define HEADER_COL 1 /* column in which group headers are printed */
102 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
103 #define RMARGIN 79 /* right margin used for wrapping */
105 /* User-selectable (using an environment variable) formatting parameters.
106 They must all be of type `int' for the parsing code to work. */
109 /* If true, arguments for an option are shown with both short and long
110 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
111 If false, then if an option has both, the argument is only shown with
112 the long one, e.g., `-x, --longx=ARG', and a message indicating that
113 this really means both is printed below the options. */
116 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
117 been suppressed, an explanatory message should be printed. */
120 /* Various output columns. */
129 int valid; /* True when the values in here are valid. */
132 /* This is a global variable, as user options are only ever read once. */
133 static struct uparams uparams = {
134 DUP_ARGS, DUP_ARGS_NOTE,
135 SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,
136 USAGE_INDENT, RMARGIN,
140 /* A particular uparam, and what the user name is. */
143 const char *name; /* User name. */
144 int is_bool; /* Whether it's `boolean'. */
145 size_t uparams_offs; /* Location of the (int) field in UPARAMS. */
148 /* The name-field mappings we know about. */
149 static const struct uparam_name uparam_names[] =
151 { "dup-args", 1, offsetof (struct uparams, dup_args) },
152 { "dup-args-note", 1, offsetof (struct uparams, dup_args_note) },
153 { "short-opt-col", 0, offsetof (struct uparams, short_opt_col) },
154 { "long-opt-col", 0, offsetof (struct uparams, long_opt_col) },
155 { "doc-opt-col", 0, offsetof (struct uparams, doc_opt_col) },
156 { "opt-doc-col", 0, offsetof (struct uparams, opt_doc_col) },
157 { "header-col", 0, offsetof (struct uparams, header_col) },
158 { "usage-indent", 0, offsetof (struct uparams, usage_indent) },
159 { "rmargin", 0, offsetof (struct uparams, rmargin) },
163 /* Read user options from the environment, and fill in UPARAMS appropiately. */
165 fill_in_uparams (const struct argp_state *state)
167 const char *var = getenv ("ARGP_HELP_FMT");
169 #define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
180 const struct uparam_name *un;
181 int unspec = 0, val = 0;
182 const char *arg = var;
184 while (isalnum (*arg) || *arg == '-' || *arg == '_')
190 if (*arg == '\0' || *arg == ',')
192 else if (*arg == '=')
200 if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')
209 else if (isdigit (*arg))
212 while (isdigit (*arg))
217 for (un = uparam_names; un->name; un++)
218 if (strlen (un->name) == var_len
219 && strncmp (var, un->name, var_len) == 0)
221 if (unspec && !un->is_bool)
222 __argp_failure (state, 0, 0,
223 dgettext (state->root_argp->argp_domain, "\
224 %.*s: ARGP_HELP_FMT parameter requires a value"),
227 *(int *)((char *)&uparams + un->uparams_offs) = val;
231 __argp_failure (state, 0, 0,
232 dgettext (state->root_argp->argp_domain, "\
233 %.*s: Unknown ARGP_HELP_FMT parameter"),
242 __argp_failure (state, 0, 0,
243 dgettext (state->root_argp->argp_domain,
244 "Garbage in ARGP_HELP_FMT: %s"), var);
250 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
251 whether OPT is displayed or used in sorting, not option shadowing. */
252 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
254 /* Returns true if OPT is an alias for an earlier option. */
255 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
257 /* Returns true if OPT is an documentation-only entry. */
258 #define odoc(opt) ((opt)->flags & OPTION_DOC)
260 /* Returns true if OPT is the end-of-list marker for a list of options. */
261 #define oend(opt) __option_is_end (opt)
263 /* Returns true if OPT has a short option. */
264 #define oshort(opt) __option_is_short (opt)
267 The help format for a particular option is like:
269 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
271 Where ARG will be omitted if there's no argument, for this option, or
272 will be surrounded by "[" and "]" appropiately if the argument is
273 optional. The documentation string is word-wrapped appropiately, and if
274 the list of options is long enough, it will be started on a separate line.
275 If there are no short options for a given option, the first long option is
276 indented slighly in a way that's supposed to make most long options appear
277 to be in a separate column.
279 For example, the following output (from ps):
281 -p PID, --pid=PID List the process PID
282 --pgrp=PGRP List processes in the process group PGRP
283 -P, -x, --no-parent Include processes without parents
284 -Q, --all-fields Don't elide unusable fields (normally if there's
285 some reason ps can't print a field for any
286 process, it's removed from the output entirely)
287 -r, --reverse, --gratuitously-long-reverse-option
288 Reverse the order of any sort
289 --session[=SID] Add the processes from the session SID (which
290 defaults to the sid of the current process)
292 Here are some more options:
293 -f ZOT, --foonly=ZOT Glork a foonly
294 -z, --zaza Snit a zar
296 -?, --help Give this help list
297 --usage Give a short usage message
298 -V, --version Print program version
300 The struct argp_option array for the above could look like:
303 {"pid", 'p', "PID", 0, "List the process PID"},
304 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
305 {"no-parent", 'P', 0, 0, "Include processes without parents"},
306 {0, 'x', 0, OPTION_ALIAS},
307 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
308 " if there's some reason ps can't"
309 " print a field for any process, it's"
310 " removed from the output entirely)" },
311 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
312 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
313 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
314 "Add the processes from the session"
315 " SID (which defaults to the sid of"
316 " the current process)" },
318 {0,0,0,0, "Here are some more options:"},
319 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
320 {"zaza", 'z', 0, 0, "Snit a zar"},
325 Note that the last three options are automatically supplied by argp_parse,
326 unless you tell it not to with ARGP_NO_HELP.
330 /* Returns true if CH occurs between BEG and END. */
332 find_char (char ch, char *beg, char *end)
342 struct hol_cluster; /* fwd decl */
347 const struct argp_option *opt;
348 /* Number of options (including aliases). */
351 /* A pointers into the HOL's short_options field, to the first short option
352 letter for this entry. The order of the characters following this point
353 corresponds to the order of options pointed to by OPT, and there are at
354 most NUM. A short option recorded in a option following OPT is only
355 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
356 probably been shadowed by some other entry). */
359 /* Entries are sorted by their group first, in the order:
360 1, 2, ..., n, 0, -m, ..., -2, -1
361 and then alphabetically within each group. The default is 0. */
364 /* The cluster of options this entry belongs to, or 0 if none. */
365 struct hol_cluster *cluster;
367 /* The argp from which this option came. */
368 const struct argp *argp;
371 /* A cluster of entries to reflect the argp tree structure. */
374 /* A descriptive header printed before options in this cluster. */
377 /* Used to order clusters within the same group with the same parent,
378 according to the order in which they occurred in the parent argp's child
382 /* How to sort this cluster with respect to options and other clusters at the
383 same depth (clusters always follow options in the same group). */
386 /* The cluster to which this cluster belongs, or 0 if it's at the base
388 struct hol_cluster *parent;
390 /* The argp from which this cluster is (eventually) derived. */
391 const struct argp *argp;
393 /* The distance this cluster is from the root. */
396 /* Clusters in a given hol are kept in a linked list, to make freeing them
398 struct hol_cluster *next;
401 /* A list of options for help. */
404 /* An array of hol_entry's. */
405 struct hol_entry *entries;
406 /* The number of entries in this hol. If this field is zero, the others
408 unsigned num_entries;
410 /* A string containing all short options in this HOL. Each entry contains
411 pointers into this string, so the order can't be messed with blindly. */
414 /* Clusters of entries in this hol. */
415 struct hol_cluster *clusters;
418 /* Create a struct hol from the options in ARGP. CLUSTER is the
419 hol_cluster in which these entries occur, or 0, if at the root. */
421 make_hol (const struct argp *argp, struct hol_cluster *cluster)
424 const struct argp_option *o;
425 const struct argp_option *opts = argp->options;
426 struct hol_entry *entry;
427 unsigned num_short_options = 0;
428 struct hol *hol = malloc (sizeof (struct hol));
432 hol->num_entries = 0;
439 /* The first option must not be an alias. */
440 assert (! oalias (opts));
442 /* Calculate the space needed. */
443 for (o = opts; ! oend (o); o++)
448 num_short_options++; /* This is an upper bound. */
451 hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);
452 hol->short_options = malloc (num_short_options + 1);
454 assert (hol->entries && hol->short_options
455 && hol->num_entries <= SIZE_MAX / sizeof (struct hol_entry));
457 /* Fill in the entries. */
458 so = hol->short_options;
459 for (o = opts, entry = hol->entries; ! oend (o); entry++)
463 entry->short_options = so;
464 entry->group = cur_group =
467 : ((!o->name && !o->key)
470 entry->cluster = cluster;
476 if (oshort (o) && ! find_char (o->key, hol->short_options, so))
477 /* O has a valid short option which hasn't already been used.*/
481 while (! oend (o) && oalias (o));
483 *so = '\0'; /* null terminated so we can find the length */
489 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
490 associated argp child list entry), INDEX, and PARENT, and return a pointer
491 to it. ARGP is the argp that this cluster results from. */
492 static struct hol_cluster *
493 hol_add_cluster (struct hol *hol, int group, const char *header, int index,
494 struct hol_cluster *parent, const struct argp *argp)
496 struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));
505 cl->depth = parent ? parent->depth + 1 : 0;
507 cl->next = hol->clusters;
513 /* Free HOL and any resources it uses. */
515 hol_free (struct hol *hol)
517 struct hol_cluster *cl = hol->clusters;
521 struct hol_cluster *next = cl->next;
526 if (hol->num_entries > 0)
529 free (hol->short_options);
536 hol_entry_short_iterate (const struct hol_entry *entry,
537 int (*func)(const struct argp_option *opt,
538 const struct argp_option *real,
539 const char *domain, void *cookie),
540 const char *domain, void *cookie)
544 const struct argp_option *opt, *real = entry->opt;
545 char *so = entry->short_options;
547 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
548 if (oshort (opt) && *so == opt->key)
553 val = (*func)(opt, real, domain, cookie);
561 __attribute__ ((always_inline))
562 hol_entry_long_iterate (const struct hol_entry *entry,
563 int (*func)(const struct argp_option *opt,
564 const struct argp_option *real,
565 const char *domain, void *cookie),
566 const char *domain, void *cookie)
570 const struct argp_option *opt, *real = entry->opt;
572 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
578 val = (*func)(opt, real, domain, cookie);
584 /* Iterator that returns true for the first short option. */
586 until_short (const struct argp_option *opt, const struct argp_option *real,
587 const char *domain, void *cookie)
589 return oshort (opt) ? opt->key : 0;
592 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
594 hol_entry_first_short (const struct hol_entry *entry)
596 return hol_entry_short_iterate (entry, until_short,
597 entry->argp->argp_domain, 0);
600 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
602 hol_entry_first_long (const struct hol_entry *entry)
604 const struct argp_option *opt;
606 for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
607 if (opt->name && ovisible (opt))
612 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
614 static struct hol_entry *
615 hol_find_entry (struct hol *hol, const char *name)
617 struct hol_entry *entry = hol->entries;
618 unsigned num_entries = hol->num_entries;
620 while (num_entries-- > 0)
622 const struct argp_option *opt = entry->opt;
623 unsigned num_opts = entry->num;
625 while (num_opts-- > 0)
626 if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
637 /* If an entry with the long option NAME occurs in HOL, set it's special
638 sort position to GROUP. */
640 hol_set_group (struct hol *hol, const char *name, int group)
642 struct hol_entry *entry = hol_find_entry (hol, name);
644 entry->group = group;
647 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
648 EQ is what to return if GROUP1 and GROUP2 are the same. */
650 group_cmp (int group1, int group2, int eq)
652 if (group1 == group2)
654 else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
655 return group1 - group2;
657 return group2 - group1;
660 /* Compare clusters CL1 & CL2 by the order that they should appear in
663 hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
665 /* If one cluster is deeper than the other, use its ancestor at the same
666 level, so that finding the common ancestor is straightforward. */
667 while (cl1->depth < cl2->depth)
669 while (cl2->depth < cl1->depth)
672 /* Now reduce both clusters to their ancestors at the point where both have
673 a common parent; these can be directly compared. */
674 while (cl1->parent != cl2->parent)
675 cl1 = cl1->parent, cl2 = cl2->parent;
677 return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
680 /* Return the ancestor of CL that's just below the root (i.e., has a parent
682 static struct hol_cluster *
683 hol_cluster_base (struct hol_cluster *cl)
690 /* Return true if CL1 is a child of CL2. */
692 hol_cluster_is_child (const struct hol_cluster *cl1,
693 const struct hol_cluster *cl2)
695 while (cl1 && cl1 != cl2)
700 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
701 that should be used for comparisons, and returns true iff it should be
702 treated as a non-option. */
704 canon_doc_option (const char **name)
707 /* Skip initial whitespace. */
708 while (isspace (**name))
710 /* Decide whether this looks like an option (leading `-') or not. */
711 non_opt = (**name != '-');
712 /* Skip until part of name used for sorting. */
713 while (**name && !isalnum (**name))
718 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
721 hol_entry_cmp (const struct hol_entry *entry1,
722 const struct hol_entry *entry2)
724 /* The group numbers by which the entries should be ordered; if either is
725 in a cluster, then this is just the group within the cluster. */
726 int group1 = entry1->group, group2 = entry2->group;
728 if (entry1->cluster != entry2->cluster)
730 /* The entries are not within the same cluster, so we can't compare them
731 directly, we have to use the appropiate clustering level too. */
732 if (! entry1->cluster)
733 /* ENTRY1 is at the `base level', not in a cluster, so we have to
734 compare it's group number with that of the base cluster in which
735 ENTRY2 resides. Note that if they're in the same group, the
736 clustered option always comes laster. */
737 return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
738 else if (! entry2->cluster)
739 /* Likewise, but ENTRY2's not in a cluster. */
740 return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
742 /* Both entries are in clusters, we can just compare the clusters. */
743 return hol_cluster_cmp (entry1->cluster, entry2->cluster);
745 else if (group1 == group2)
746 /* The entries are both in the same cluster and group, so compare them
749 int short1 = hol_entry_first_short (entry1);
750 int short2 = hol_entry_first_short (entry2);
751 int doc1 = odoc (entry1->opt);
752 int doc2 = odoc (entry2->opt);
753 const char *long1 = hol_entry_first_long (entry1);
754 const char *long2 = hol_entry_first_long (entry2);
757 doc1 = canon_doc_option (&long1);
759 doc2 = canon_doc_option (&long2);
762 /* `documentation' options always follow normal options (or
763 documentation options that *look* like normal options). */
765 else if (!short1 && !short2 && long1 && long2)
766 /* Only long options. */
767 return __strcasecmp (long1, long2);
769 /* Compare short/short, long/short, short/long, using the first
770 character of long options. Entries without *any* valid
771 options (such as options with OPTION_HIDDEN set) will be put
772 first, but as they're not displayed, it doesn't matter where
775 char first1 = short1 ? short1 : long1 ? *long1 : 0;
776 char first2 = short2 ? short2 : long2 ? *long2 : 0;
778 int lower_cmp = _tolower (first1) - _tolower (first2);
780 int lower_cmp = tolower (first1) - tolower (first2);
782 /* Compare ignoring case, except when the options are both the
783 same letter, in which case lower-case always comes first. */
784 return lower_cmp ? lower_cmp : first2 - first1;
788 /* Within the same cluster, but not the same group, so just compare
790 return group_cmp (group1, group2, 0);
793 /* Version of hol_entry_cmp with correct signature for qsort. */
795 hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
797 return hol_entry_cmp (entry1_v, entry2_v);
800 /* Sort HOL by group and alphabetically by option name (with short options
801 taking precedence over long). Since the sorting is for display purposes
802 only, the shadowing of options isn't effected. */
804 hol_sort (struct hol *hol)
806 if (hol->num_entries > 0)
807 qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
811 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
812 any in MORE with the same name. */
814 hol_append (struct hol *hol, struct hol *more)
816 struct hol_cluster **cl_end = &hol->clusters;
818 /* Steal MORE's cluster list, and add it to the end of HOL's. */
820 cl_end = &(*cl_end)->next;
821 *cl_end = more->clusters;
825 if (more->num_entries > 0)
827 if (hol->num_entries == 0)
829 hol->num_entries = more->num_entries;
830 hol->entries = more->entries;
831 hol->short_options = more->short_options;
832 more->num_entries = 0; /* Mark MORE's fields as invalid. */
835 /* Append the entries in MORE to those in HOL, taking care to only add
836 non-shadowed SHORT_OPTIONS values. */
841 unsigned num_entries = hol->num_entries + more->num_entries;
842 struct hol_entry *entries =
843 malloc (num_entries * sizeof (struct hol_entry));
844 unsigned hol_so_len = strlen (hol->short_options);
845 char *short_options =
846 malloc (hol_so_len + strlen (more->short_options) + 1);
848 assert (entries && short_options
849 && num_entries <= SIZE_MAX / sizeof (struct hol_entry));
851 __mempcpy (__mempcpy (entries, hol->entries,
852 hol->num_entries * sizeof (struct hol_entry)),
854 more->num_entries * sizeof (struct hol_entry));
856 __mempcpy (short_options, hol->short_options, hol_so_len);
858 /* Fix up the short options pointers from HOL. */
859 for (e = entries, left = hol->num_entries; left > 0; e++, left--)
860 e->short_options += (short_options - hol->short_options);
862 /* Now add the short options from MORE, fixing up its entries
864 so = short_options + hol_so_len;
865 more_so = more->short_options;
866 for (left = more->num_entries; left > 0; e++, left--)
869 const struct argp_option *opt;
871 e->short_options = so;
873 for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
876 if (oshort (opt) && ch == opt->key)
877 /* The next short option in MORE_SO, CH, is from OPT. */
879 if (! find_char (ch, short_options,
880 short_options + hol_so_len))
881 /* The short option CH isn't shadowed by HOL's options,
882 so add it to the sum. */
892 free (hol->short_options);
894 hol->entries = entries;
895 hol->num_entries = num_entries;
896 hol->short_options = short_options;
903 /* Inserts enough spaces to make sure STREAM is at column COL. */
905 indent_to (argp_fmtstream_t stream, unsigned col)
907 int needed = col - __argp_fmtstream_point (stream);
909 __argp_fmtstream_putc (stream, ' ');
912 /* Output to STREAM either a space, or a newline if there isn't room for at
913 least ENSURE characters before the right margin. */
915 space (argp_fmtstream_t stream, size_t ensure)
917 if (__argp_fmtstream_point (stream) + ensure
918 >= __argp_fmtstream_rmargin (stream))
919 __argp_fmtstream_putc (stream, '\n');
921 __argp_fmtstream_putc (stream, ' ');
924 /* If the option REAL has an argument, we print it in using the printf
925 format REQ_FMT or OPT_FMT depending on whether it's a required or
926 optional argument. */
928 arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
929 const char *domain, argp_fmtstream_t stream)
933 if (real->flags & OPTION_ARG_OPTIONAL)
934 __argp_fmtstream_printf (stream, opt_fmt,
935 dgettext (domain, real->arg));
937 __argp_fmtstream_printf (stream, req_fmt,
938 dgettext (domain, real->arg));
942 /* Helper functions for hol_entry_help. */
944 /* State used during the execution of hol_help. */
945 struct hol_help_state
947 /* PREV_ENTRY should contain the previous entry printed, or 0. */
948 struct hol_entry *prev_entry;
950 /* If an entry is in a different group from the previous one, and SEP_GROUPS
951 is true, then a blank line will be printed before any output. */
954 /* True if a duplicate option argument was suppressed (only ever set if
955 UPARAMS.dup_args is false). */
956 int suppressed_dup_arg;
959 /* Some state used while printing a help entry (used to communicate with
960 helper functions). See the doc for hol_entry_help for more info, as most
961 of the fields are copied from its arguments. */
964 const struct hol_entry *entry;
965 argp_fmtstream_t stream;
966 struct hol_help_state *hhstate;
968 /* True if nothing's been printed so far. */
971 /* If non-zero, the state that was used to print this help. */
972 const struct argp_state *state;
975 /* If a user doc filter should be applied to DOC, do so. */
977 filter_doc (const char *doc, int key, const struct argp *argp,
978 const struct argp_state *state)
980 if (argp->help_filter)
981 /* We must apply a user filter to this output. */
983 void *input = __argp_input (argp, state);
984 return (*argp->help_filter) (key, doc, input);
991 /* Prints STR as a header line, with the margin lines set appropiately, and
992 notes the fact that groups should be separated with a blank line. ARGP is
993 the argp that should dictate any user doc filtering to take place. Note
994 that the previous wrap margin isn't restored, but the left margin is reset
997 print_header (const char *str, const struct argp *argp,
998 struct pentry_state *pest)
1000 const char *tstr = dgettext (argp->argp_domain, str);
1001 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
1007 if (pest->hhstate->prev_entry)
1008 /* Precede with a blank line. */
1009 __argp_fmtstream_putc (pest->stream, '\n');
1010 indent_to (pest->stream, uparams.header_col);
1011 __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
1012 __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
1013 __argp_fmtstream_puts (pest->stream, fstr);
1014 __argp_fmtstream_set_lmargin (pest->stream, 0);
1015 __argp_fmtstream_putc (pest->stream, '\n');
1018 pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
1022 free ((char *) fstr);
1025 /* Inserts a comma if this isn't the first item on the line, and then makes
1026 sure we're at least to column COL. If this *is* the first item on a line,
1027 prints any pending whitespace/headers that should precede this line. Also
1030 comma (unsigned col, struct pentry_state *pest)
1034 const struct hol_entry *pe = pest->hhstate->prev_entry;
1035 const struct hol_cluster *cl = pest->entry->cluster;
1037 if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
1038 __argp_fmtstream_putc (pest->stream, '\n');
1040 if (cl && cl->header && *cl->header
1042 || (pe->cluster != cl
1043 && !hol_cluster_is_child (pe->cluster, cl))))
1044 /* If we're changing clusters, then this must be the start of the
1045 ENTRY's cluster unless that is an ancestor of the previous one
1046 (in which case we had just popped into a sub-cluster for a bit).
1047 If so, then print the cluster's header line. */
1049 int old_wm = __argp_fmtstream_wmargin (pest->stream);
1050 print_header (cl->header, cl->argp, pest);
1051 __argp_fmtstream_set_wmargin (pest->stream, old_wm);
1057 __argp_fmtstream_puts (pest->stream, ", ");
1059 indent_to (pest->stream, col);
1062 /* Print help for ENTRY to STREAM. */
1064 hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
1065 argp_fmtstream_t stream, struct hol_help_state *hhstate)
1068 const struct argp_option *real = entry->opt, *opt;
1069 char *so = entry->short_options;
1070 int have_long_opt = 0; /* We have any long options. */
1071 /* Saved margins. */
1072 int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
1073 int old_wm = __argp_fmtstream_wmargin (stream);
1074 /* PEST is a state block holding some of our variables that we'd like to
1075 share with helper functions. */
1076 struct pentry_state pest = { entry, stream, hhstate, 1, state };
1079 for (opt = real, num = entry->num; num > 0; opt++, num--)
1080 if (opt->name && ovisible (opt))
1086 /* First emit short options. */
1087 __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
1088 for (opt = real, num = entry->num; num > 0; opt++, num--)
1089 if (oshort (opt) && opt->key == *so)
1090 /* OPT has a valid (non shadowed) short option. */
1094 comma (uparams.short_opt_col, &pest);
1095 __argp_fmtstream_putc (stream, '-');
1096 __argp_fmtstream_putc (stream, *so);
1097 if (!have_long_opt || uparams.dup_args)
1098 arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
1100 hhstate->suppressed_dup_arg = 1;
1105 /* Now, long options. */
1107 /* A `documentation' option. */
1109 __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
1110 for (opt = real, num = entry->num; num > 0; opt++, num--)
1111 if (opt->name && ovisible (opt))
1113 comma (uparams.doc_opt_col, &pest);
1114 /* Calling gettext here isn't quite right, since sorting will
1115 have been done on the original; but documentation options
1116 should be pretty rare anyway... */
1117 __argp_fmtstream_puts (stream,
1118 dgettext (state->root_argp->argp_domain,
1123 /* A real long option. */
1125 int first_long_opt = 1;
1127 __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
1128 for (opt = real, num = entry->num; num > 0; opt++, num--)
1129 if (opt->name && ovisible (opt))
1131 comma (uparams.long_opt_col, &pest);
1132 __argp_fmtstream_printf (stream, "--%s", opt->name);
1133 if (first_long_opt || uparams.dup_args)
1134 arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
1137 hhstate->suppressed_dup_arg = 1;
1141 /* Next, documentation strings. */
1142 __argp_fmtstream_set_lmargin (stream, 0);
1146 /* Didn't print any switches, what's up? */
1147 if (!oshort (real) && !real->name)
1148 /* This is a group header, print it nicely. */
1149 print_header (real->doc, entry->argp, &pest);
1151 /* Just a totally shadowed option or null header; print nothing. */
1152 goto cleanup; /* Just return, after cleaning up. */
1156 const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
1158 const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
1161 unsigned int col = __argp_fmtstream_point (stream);
1163 __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
1164 __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
1166 if (col > (unsigned int) (uparams.opt_doc_col + 3))
1167 __argp_fmtstream_putc (stream, '\n');
1168 else if (col >= (unsigned int) uparams.opt_doc_col)
1169 __argp_fmtstream_puts (stream, " ");
1171 indent_to (stream, uparams.opt_doc_col);
1173 __argp_fmtstream_puts (stream, fstr);
1175 if (fstr && fstr != tstr)
1176 free ((char *) fstr);
1178 /* Reset the left margin. */
1179 __argp_fmtstream_set_lmargin (stream, 0);
1180 __argp_fmtstream_putc (stream, '\n');
1183 hhstate->prev_entry = entry;
1186 __argp_fmtstream_set_lmargin (stream, old_lm);
1187 __argp_fmtstream_set_wmargin (stream, old_wm);
1190 /* Output a long help message about the options in HOL to STREAM. */
1192 hol_help (struct hol *hol, const struct argp_state *state,
1193 argp_fmtstream_t stream)
1196 struct hol_entry *entry;
1197 struct hol_help_state hhstate = { 0, 0, 0 };
1199 for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
1200 hol_entry_help (entry, state, stream, &hhstate);
1202 if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
1204 const char *tstr = dgettext (state->root_argp->argp_domain, "\
1205 Mandatory or optional arguments to long options are also mandatory or \
1206 optional for any corresponding short options.");
1207 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
1208 state ? state->root_argp : 0, state);
1211 __argp_fmtstream_putc (stream, '\n');
1212 __argp_fmtstream_puts (stream, fstr);
1213 __argp_fmtstream_putc (stream, '\n');
1215 if (fstr && fstr != tstr)
1216 free ((char *) fstr);
1220 /* Helper functions for hol_usage. */
1222 /* If OPT is a short option without an arg, append its key to the string
1223 pointer pointer to by COOKIE, and advance the pointer. */
1225 add_argless_short_opt (const struct argp_option *opt,
1226 const struct argp_option *real,
1227 const char *domain, void *cookie)
1229 char **snao_end = cookie;
1230 if (!(opt->arg || real->arg)
1231 && !((opt->flags | real->flags) & OPTION_NO_USAGE))
1232 *(*snao_end)++ = opt->key;
1236 /* If OPT is a short option with an arg, output a usage entry for it to the
1237 stream pointed at by COOKIE. */
1239 usage_argful_short_opt (const struct argp_option *opt,
1240 const struct argp_option *real,
1241 const char *domain, void *cookie)
1243 argp_fmtstream_t stream = cookie;
1244 const char *arg = opt->arg;
1245 int flags = opt->flags | real->flags;
1250 if (arg && !(flags & OPTION_NO_USAGE))
1252 arg = dgettext (domain, arg);
1254 if (flags & OPTION_ARG_OPTIONAL)
1255 __argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
1258 /* Manually do line wrapping so that it (probably) won't
1259 get wrapped at the embedded space. */
1260 space (stream, 6 + strlen (arg));
1261 __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
1268 /* Output a usage entry for the long option opt to the stream pointed at by
1271 usage_long_opt (const struct argp_option *opt,
1272 const struct argp_option *real,
1273 const char *domain, void *cookie)
1275 argp_fmtstream_t stream = cookie;
1276 const char *arg = opt->arg;
1277 int flags = opt->flags | real->flags;
1282 if (! (flags & OPTION_NO_USAGE))
1286 arg = dgettext (domain, arg);
1287 if (flags & OPTION_ARG_OPTIONAL)
1288 __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
1290 __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
1293 __argp_fmtstream_printf (stream, " [--%s]", opt->name);
1299 /* Print a short usage description for the arguments in HOL to STREAM. */
1301 hol_usage (struct hol *hol, argp_fmtstream_t stream)
1303 if (hol->num_entries > 0)
1306 struct hol_entry *entry;
1307 char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
1308 char *snao_end = short_no_arg_opts;
1310 /* First we put a list of short options without arguments. */
1311 for (entry = hol->entries, nentries = hol->num_entries
1313 ; entry++, nentries--)
1314 hol_entry_short_iterate (entry, add_argless_short_opt,
1315 entry->argp->argp_domain, &snao_end);
1316 if (snao_end > short_no_arg_opts)
1319 __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
1322 /* Now a list of short options *with* arguments. */
1323 for (entry = hol->entries, nentries = hol->num_entries
1325 ; entry++, nentries--)
1326 hol_entry_short_iterate (entry, usage_argful_short_opt,
1327 entry->argp->argp_domain, stream);
1329 /* Finally, a list of long options (whew!). */
1330 for (entry = hol->entries, nentries = hol->num_entries
1332 ; entry++, nentries--)
1333 hol_entry_long_iterate (entry, usage_long_opt,
1334 entry->argp->argp_domain, stream);
1338 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1339 cluster in which ARGP's entries should be clustered, or 0. */
1341 argp_hol (const struct argp *argp, struct hol_cluster *cluster)
1343 const struct argp_child *child = argp->children;
1344 struct hol *hol = make_hol (argp, cluster);
1348 struct hol_cluster *child_cluster =
1349 ((child->group || child->header)
1350 /* Put CHILD->argp within its own cluster. */
1351 ? hol_add_cluster (hol, child->group, child->header,
1352 child - argp->children, cluster, argp)
1353 /* Just merge it into the parent's cluster. */
1355 hol_append (hol, argp_hol (child->argp, child_cluster)) ;
1361 /* Calculate how many different levels with alternative args strings exist in
1364 argp_args_levels (const struct argp *argp)
1367 const struct argp_child *child = argp->children;
1369 if (argp->args_doc && strchr (argp->args_doc, '\n'))
1374 levels += argp_args_levels ((child++)->argp);
1379 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1380 preceded by a space. LEVELS is a pointer to a byte vector the length
1381 returned by argp_args_levels; it should be initialized to zero, and
1382 updated by this routine for the next call if ADVANCE is true. True is
1383 returned as long as there are more patterns to output. */
1385 argp_args_usage (const struct argp *argp, const struct argp_state *state,
1386 char **levels, int advance, argp_fmtstream_t stream)
1388 char *our_level = *levels;
1390 const struct argp_child *child = argp->children;
1391 const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
1392 const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
1396 const char *cp = fdoc;
1397 nl = __strchrnul (cp, '\n');
1399 /* This is a `multi-level' args doc; advance to the correct position
1400 as determined by our state in LEVELS, and update LEVELS. */
1404 for (i = 0; i < *our_level; i++)
1405 cp = nl + 1, nl = __strchrnul (cp, '\n');
1409 /* Manually do line wrapping so that it (probably) won't get wrapped at
1410 any embedded spaces. */
1411 space (stream, 1 + nl - cp);
1413 __argp_fmtstream_write (stream, cp, nl - cp);
1415 if (fdoc && fdoc != tdoc)
1416 free ((char *)fdoc); /* Free user's modified doc string. */
1420 advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
1422 if (advance && multiple)
1424 /* Need to increment our level. */
1426 /* There's more we can do here. */
1429 advance = 0; /* Our parent shouldn't advance also. */
1431 else if (*our_level > 0)
1432 /* We had multiple levels, but used them up; reset to zero. */
1439 /* Print the documentation for ARGP to STREAM; if POST is false, then
1440 everything preceeding a `\v' character in the documentation strings (or
1441 the whole string, for those with none) is printed, otherwise, everything
1442 following the `\v' character (nothing for strings without). Each separate
1443 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1444 then the first is as well. If FIRST_ONLY is true, only the first
1445 occurrence is output. Returns true if anything was output. */
1447 argp_doc (const struct argp *argp, const struct argp_state *state,
1448 int post, int pre_blank, int first_only,
1449 argp_fmtstream_t stream)
1452 const char *inp_text;
1455 size_t inp_text_limit = 0;
1456 const char *doc = dgettext (argp->argp_domain, argp->doc);
1457 const struct argp_child *child = argp->children;
1461 char *vt = strchr (doc, '\v');
1462 inp_text = post ? (vt ? vt + 1 : 0) : doc;
1463 inp_text_limit = (!post && vt) ? (vt - doc) : 0;
1468 if (argp->help_filter)
1469 /* We have to filter the doc strings. */
1472 /* Copy INP_TEXT so that it's nul-terminated. */
1473 inp_text = __strndup (inp_text, inp_text_limit);
1474 input = __argp_input (argp, state);
1476 (*argp->help_filter) (post
1477 ? ARGP_KEY_HELP_POST_DOC
1478 : ARGP_KEY_HELP_PRE_DOC,
1482 text = (const char *) inp_text;
1487 __argp_fmtstream_putc (stream, '\n');
1489 if (text == inp_text && inp_text_limit)
1490 __argp_fmtstream_write (stream, inp_text, inp_text_limit);
1492 __argp_fmtstream_puts (stream, text);
1494 if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
1495 __argp_fmtstream_putc (stream, '\n');
1500 if (text && text != inp_text)
1501 free ((char *) text); /* Free TEXT returned from the help filter. */
1502 if (inp_text && inp_text_limit && argp->help_filter)
1503 free ((char *) inp_text); /* We copied INP_TEXT, so free it now. */
1505 if (post && argp->help_filter)
1506 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1508 text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
1511 if (anything || pre_blank)
1512 __argp_fmtstream_putc (stream, '\n');
1513 __argp_fmtstream_puts (stream, text);
1514 free ((char *) text);
1515 if (__argp_fmtstream_point (stream)
1516 > __argp_fmtstream_lmargin (stream))
1517 __argp_fmtstream_putc (stream, '\n');
1523 while (child->argp && !(first_only && anything))
1525 argp_doc ((child++)->argp, state,
1526 post, anything || pre_blank, first_only,
1532 /* Output a usage message for ARGP to STREAM. If called from
1533 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1534 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1537 _help (const struct argp *argp, const struct argp_state *state, FILE *stream,
1538 unsigned flags, char *name)
1540 int anything = 0; /* Whether we've output anything. */
1541 struct hol *hol = 0;
1542 argp_fmtstream_t fs;
1547 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1548 __flockfile (stream);
1551 if (! uparams.valid)
1552 fill_in_uparams (state);
1554 fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
1557 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1558 __funlockfile (stream);
1563 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
1565 hol = argp_hol (argp, 0);
1567 /* If present, these options always come last. */
1568 hol_set_group (hol, "help", -1);
1569 hol_set_group (hol, "version", -1);
1574 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
1575 /* Print a short `Usage:' message. */
1577 int first_pattern = 1, more_patterns;
1578 size_t num_pattern_levels = argp_args_levels (argp);
1579 char *pattern_levels = alloca (num_pattern_levels);
1581 memset (pattern_levels, 0, num_pattern_levels);
1586 int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
1587 char *levels = pattern_levels;
1590 __argp_fmtstream_printf (fs, "%s %s",
1591 dgettext (argp->argp_domain, "Usage:"),
1594 __argp_fmtstream_printf (fs, "%s %s",
1595 dgettext (argp->argp_domain, " or: "),
1598 /* We set the lmargin as well as the wmargin, because hol_usage
1599 manually wraps options with newline to avoid annoying breaks. */
1600 old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
1602 if (flags & ARGP_HELP_SHORT_USAGE)
1603 /* Just show where the options go. */
1605 if (hol->num_entries > 0)
1606 __argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
1610 /* Actually print the options. */
1612 hol_usage (hol, fs);
1613 flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once. */
1616 more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
1618 __argp_fmtstream_set_wmargin (fs, old_wm);
1619 __argp_fmtstream_set_lmargin (fs, old_lm);
1621 __argp_fmtstream_putc (fs, '\n');
1626 while (more_patterns);
1629 if (flags & ARGP_HELP_PRE_DOC)
1630 anything |= argp_doc (argp, state, 0, 0, 1, fs);
1632 if (flags & ARGP_HELP_SEE)
1634 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
1635 Try `%s --help' or `%s --usage' for more information.\n"),
1640 if (flags & ARGP_HELP_LONG)
1641 /* Print a long, detailed help message. */
1643 /* Print info about all the options. */
1644 if (hol->num_entries > 0)
1647 __argp_fmtstream_putc (fs, '\n');
1648 hol_help (hol, state, fs);
1653 if (flags & ARGP_HELP_POST_DOC)
1654 /* Print any documentation strings at the end. */
1655 anything |= argp_doc (argp, state, 1, anything, 0, fs);
1657 if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
1660 __argp_fmtstream_putc (fs, '\n');
1661 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
1662 "Report bugs to %s.\n"),
1663 argp_program_bug_address);
1667 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1668 __funlockfile (stream);
1674 __argp_fmtstream_free (fs);
1677 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1678 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1679 void __argp_help (const struct argp *argp, FILE *stream,
1680 unsigned flags, char *name)
1682 _help (argp, 0, stream, flags, name);
1685 weak_alias (__argp_help, argp_help)
1689 char *__argp_basename (char *name)
1691 char *short_name = strrchr (name, '/');
1692 return short_name ? short_name + 1 : name;
1696 __argp_short_program_name (void)
1698 # if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
1699 return program_invocation_short_name;
1700 # elif HAVE_DECL_PROGRAM_INVOCATION_NAME
1701 return __argp_basename (program_invocation_name);
1703 /* FIXME: What now? Miles suggests that it is better to use NULL,
1704 but currently the value is passed on directly to fputs_unlocked,
1705 so that requires more changes. */
1707 # warning No reasonable value to return
1708 # endif /* __GNUC__ */
1714 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1715 from the set ARGP_HELP_*. */
1717 __argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
1719 if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
1721 if (state && (state->flags & ARGP_LONG_ONLY))
1722 flags |= ARGP_HELP_LONG_ONLY;
1724 _help (state ? state->root_argp : 0, state, stream, flags,
1725 state ? state->name : __argp_short_program_name ());
1727 if (!state || ! (state->flags & ARGP_NO_EXIT))
1729 if (flags & ARGP_HELP_EXIT_ERR)
1730 exit (argp_err_exit_status);
1731 if (flags & ARGP_HELP_EXIT_OK)
1737 weak_alias (__argp_state_help, argp_state_help)
1740 /* If appropriate, print the printf string FMT and following args, preceded
1741 by the program name and `:', to stderr, and followed by a `Try ... --help'
1742 message, then exit (1). */
1744 __argp_error (const struct argp_state *state, const char *fmt, ...)
1746 if (!state || !(state->flags & ARGP_NO_ERRS))
1748 FILE *stream = state ? state->err_stream : stderr;
1754 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1755 __flockfile (stream);
1761 if (_IO_fwide (stream, 0) > 0)
1765 __asprintf (&buf, fmt, ap);
1767 __fwprintf (stream, L"%s: %s\n",
1768 state ? state->name : __argp_short_program_name (),
1776 fputs_unlocked (state
1777 ? state->name : __argp_short_program_name (),
1779 putc_unlocked (':', stream);
1780 putc_unlocked (' ', stream);
1782 vfprintf (stream, fmt, ap);
1784 putc_unlocked ('\n', stream);
1787 __argp_state_help (state, stream, ARGP_HELP_STD_ERR);
1791 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1792 __funlockfile (stream);
1798 weak_alias (__argp_error, argp_error)
1801 /* Similar to the standard gnu error-reporting function error(), but will
1802 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1803 to STATE->err_stream. This is useful for argument parsing code that is
1804 shared between program startup (when exiting is desired) and runtime
1805 option parsing (when typically an error code is returned instead). The
1806 difference between this function and argp_error is that the latter is for
1807 *parsing errors*, and the former is for other problems that occur during
1808 parsing but don't reflect a (syntactic) problem with the input. */
1810 __argp_failure (const struct argp_state *state, int status, int errnum,
1811 const char *fmt, ...)
1813 if (!state || !(state->flags & ARGP_NO_ERRS))
1815 FILE *stream = state ? state->err_stream : stderr;
1819 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1820 __flockfile (stream);
1824 if (_IO_fwide (stream, 0) > 0)
1825 __fwprintf (stream, L"%s",
1826 state ? state->name : __argp_short_program_name ());
1829 fputs_unlocked (state
1830 ? state->name : __argp_short_program_name (),
1839 if (_IO_fwide (stream, 0) > 0)
1843 __asprintf (&buf, fmt, ap);
1845 __fwprintf (stream, L": %s", buf);
1852 putc_unlocked (':', stream);
1853 putc_unlocked (' ', stream);
1855 vfprintf (stream, fmt, ap);
1866 if (_IO_fwide (stream, 0) > 0)
1867 __fwprintf (stream, L": %s",
1868 __strerror_r (errnum, buf, sizeof (buf)));
1872 putc_unlocked (':', stream);
1873 putc_unlocked (' ', stream);
1874 #if defined _LIBC || defined HAVE_STRERROR_R
1875 fputs (__strerror_r (errnum, buf, sizeof (buf)), stream);
1877 fputs (strerror (errnum), stream);
1883 if (_IO_fwide (stream, 0) > 0)
1884 putwc_unlocked (L'\n', stream);
1887 putc_unlocked ('\n', stream);
1889 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1890 __funlockfile (stream);
1893 if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
1899 weak_alias (__argp_failure, argp_failure)