1 /* Hierarchial argument parsing help output
2 Copyright (C) 1995-2003, 2004 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
41 /* This is for other GNU distributions with internationalized messages. */
42 # if defined HAVE_LIBINTL_H || defined _LIBC
46 # define dgettext(domain, msgid) \
47 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
50 # define dgettext(domain, msgid) (msgid)
56 # if !HAVE_DECL_STRERROR_R
57 char *strerror_r (int errnum, char *buf, size_t buflen);
60 # if !HAVE_DECL_STRERROR
61 char *strerror (int errnum);
67 #include "argp-fmtstream.h"
68 #include "argp-namefrob.h"
71 # define SIZE_MAX ((size_t) -1)
74 /* User-selectable (using an environment variable) formatting parameters.
76 These may be specified in an environment variable called `ARGP_HELP_FMT',
77 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
78 Where VALn must be a positive integer. The list of variables is in the
79 UPARAM_NAMES vector, below. */
81 /* Default parameters. */
82 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
83 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
84 #define SHORT_OPT_COL 2 /* column in which short options start */
85 #define LONG_OPT_COL 6 /* column in which long options start */
86 #define DOC_OPT_COL 2 /* column in which doc options start */
87 #define OPT_DOC_COL 29 /* column in which option text starts */
88 #define HEADER_COL 1 /* column in which group headers are printed */
89 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
90 #define RMARGIN 79 /* right margin used for wrapping */
92 /* User-selectable (using an environment variable) formatting parameters.
93 They must all be of type `int' for the parsing code to work. */
96 /* If true, arguments for an option are shown with both short and long
97 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
98 If false, then if an option has both, the argument is only shown with
99 the long one, e.g., `-x, --longx=ARG', and a message indicating that
100 this really means both is printed below the options. */
103 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
104 been suppressed, an explanatory message should be printed. */
107 /* Various output columns. */
116 int valid; /* True when the values in here are valid. */
119 /* This is a global variable, as user options are only ever read once. */
120 static struct uparams uparams = {
121 DUP_ARGS, DUP_ARGS_NOTE,
122 SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,
123 USAGE_INDENT, RMARGIN,
127 /* A particular uparam, and what the user name is. */
130 const char *name; /* User name. */
131 int is_bool; /* Whether it's `boolean'. */
132 size_t uparams_offs; /* Location of the (int) field in UPARAMS. */
135 /* The name-field mappings we know about. */
136 static const struct uparam_name uparam_names[] =
138 { "dup-args", 1, offsetof (struct uparams, dup_args) },
139 { "dup-args-note", 1, offsetof (struct uparams, dup_args_note) },
140 { "short-opt-col", 0, offsetof (struct uparams, short_opt_col) },
141 { "long-opt-col", 0, offsetof (struct uparams, long_opt_col) },
142 { "doc-opt-col", 0, offsetof (struct uparams, doc_opt_col) },
143 { "opt-doc-col", 0, offsetof (struct uparams, opt_doc_col) },
144 { "header-col", 0, offsetof (struct uparams, header_col) },
145 { "usage-indent", 0, offsetof (struct uparams, usage_indent) },
146 { "rmargin", 0, offsetof (struct uparams, rmargin) },
150 /* Read user options from the environment, and fill in UPARAMS appropiately. */
152 fill_in_uparams (const struct argp_state *state)
154 const char *var = getenv ("ARGP_HELP_FMT");
156 #define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
167 const struct uparam_name *un;
168 int unspec = 0, val = 0;
169 const char *arg = var;
171 while (isalnum (*arg) || *arg == '-' || *arg == '_')
177 if (*arg == '\0' || *arg == ',')
179 else if (*arg == '=')
187 if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')
196 else if (isdigit (*arg))
199 while (isdigit (*arg))
204 for (un = uparam_names; un->name; un++)
205 if (strlen (un->name) == var_len
206 && strncmp (var, un->name, var_len) == 0)
208 if (unspec && !un->is_bool)
209 __argp_failure (state, 0, 0,
210 dgettext (state->root_argp->argp_domain, "\
211 %.*s: ARGP_HELP_FMT parameter requires a value"),
214 *(int *)((char *)&uparams + un->uparams_offs) = val;
218 __argp_failure (state, 0, 0,
219 dgettext (state->root_argp->argp_domain, "\
220 %.*s: Unknown ARGP_HELP_FMT parameter"),
229 __argp_failure (state, 0, 0,
230 dgettext (state->root_argp->argp_domain,
231 "Garbage in ARGP_HELP_FMT: %s"), var);
237 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
238 whether OPT is displayed or used in sorting, not option shadowing. */
239 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
241 /* Returns true if OPT is an alias for an earlier option. */
242 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
244 /* Returns true if OPT is an documentation-only entry. */
245 #define odoc(opt) ((opt)->flags & OPTION_DOC)
247 /* Returns true if OPT is the end-of-list marker for a list of options. */
248 #define oend(opt) __option_is_end (opt)
250 /* Returns true if OPT has a short option. */
251 #define oshort(opt) __option_is_short (opt)
254 The help format for a particular option is like:
256 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
258 Where ARG will be omitted if there's no argument, for this option, or
259 will be surrounded by "[" and "]" appropiately if the argument is
260 optional. The documentation string is word-wrapped appropiately, and if
261 the list of options is long enough, it will be started on a separate line.
262 If there are no short options for a given option, the first long option is
263 indented slighly in a way that's supposed to make most long options appear
264 to be in a separate column.
266 For example, the following output (from ps):
268 -p PID, --pid=PID List the process PID
269 --pgrp=PGRP List processes in the process group PGRP
270 -P, -x, --no-parent Include processes without parents
271 -Q, --all-fields Don't elide unusable fields (normally if there's
272 some reason ps can't print a field for any
273 process, it's removed from the output entirely)
274 -r, --reverse, --gratuitously-long-reverse-option
275 Reverse the order of any sort
276 --session[=SID] Add the processes from the session SID (which
277 defaults to the sid of the current process)
279 Here are some more options:
280 -f ZOT, --foonly=ZOT Glork a foonly
281 -z, --zaza Snit a zar
283 -?, --help Give this help list
284 --usage Give a short usage message
285 -V, --version Print program version
287 The struct argp_option array for the above could look like:
290 {"pid", 'p', "PID", 0, "List the process PID"},
291 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
292 {"no-parent", 'P', 0, 0, "Include processes without parents"},
293 {0, 'x', 0, OPTION_ALIAS},
294 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
295 " if there's some reason ps can't"
296 " print a field for any process, it's"
297 " removed from the output entirely)" },
298 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
299 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
300 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
301 "Add the processes from the session"
302 " SID (which defaults to the sid of"
303 " the current process)" },
305 {0,0,0,0, "Here are some more options:"},
306 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
307 {"zaza", 'z', 0, 0, "Snit a zar"},
312 Note that the last three options are automatically supplied by argp_parse,
313 unless you tell it not to with ARGP_NO_HELP.
317 /* Returns true if CH occurs between BEG and END. */
319 find_char (char ch, char *beg, char *end)
329 struct hol_cluster; /* fwd decl */
334 const struct argp_option *opt;
335 /* Number of options (including aliases). */
338 /* A pointers into the HOL's short_options field, to the first short option
339 letter for this entry. The order of the characters following this point
340 corresponds to the order of options pointed to by OPT, and there are at
341 most NUM. A short option recorded in a option following OPT is only
342 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
343 probably been shadowed by some other entry). */
346 /* Entries are sorted by their group first, in the order:
347 1, 2, ..., n, 0, -m, ..., -2, -1
348 and then alphabetically within each group. The default is 0. */
351 /* The cluster of options this entry belongs to, or 0 if none. */
352 struct hol_cluster *cluster;
354 /* The argp from which this option came. */
355 const struct argp *argp;
358 /* A cluster of entries to reflect the argp tree structure. */
361 /* A descriptive header printed before options in this cluster. */
364 /* Used to order clusters within the same group with the same parent,
365 according to the order in which they occurred in the parent argp's child
369 /* How to sort this cluster with respect to options and other clusters at the
370 same depth (clusters always follow options in the same group). */
373 /* The cluster to which this cluster belongs, or 0 if it's at the base
375 struct hol_cluster *parent;
377 /* The argp from which this cluster is (eventually) derived. */
378 const struct argp *argp;
380 /* The distance this cluster is from the root. */
383 /* Clusters in a given hol are kept in a linked list, to make freeing them
385 struct hol_cluster *next;
388 /* A list of options for help. */
391 /* An array of hol_entry's. */
392 struct hol_entry *entries;
393 /* The number of entries in this hol. If this field is zero, the others
395 unsigned num_entries;
397 /* A string containing all short options in this HOL. Each entry contains
398 pointers into this string, so the order can't be messed with blindly. */
401 /* Clusters of entries in this hol. */
402 struct hol_cluster *clusters;
405 /* Create a struct hol from the options in ARGP. CLUSTER is the
406 hol_cluster in which these entries occur, or 0, if at the root. */
408 make_hol (const struct argp *argp, struct hol_cluster *cluster)
411 const struct argp_option *o;
412 const struct argp_option *opts = argp->options;
413 struct hol_entry *entry;
414 unsigned num_short_options = 0;
415 struct hol *hol = malloc (sizeof (struct hol));
419 hol->num_entries = 0;
426 /* The first option must not be an alias. */
427 assert (! oalias (opts));
429 /* Calculate the space needed. */
430 for (o = opts; ! oend (o); o++)
435 num_short_options++; /* This is an upper bound. */
438 hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);
439 hol->short_options = malloc (num_short_options + 1);
441 assert (hol->entries && hol->short_options);
442 if (SIZE_MAX <= UINT_MAX)
443 assert (hol->num_entries <= SIZE_MAX / sizeof (struct hol_entry));
445 /* Fill in the entries. */
446 so = hol->short_options;
447 for (o = opts, entry = hol->entries; ! oend (o); entry++)
451 entry->short_options = so;
452 entry->group = cur_group =
455 : ((!o->name && !o->key)
458 entry->cluster = cluster;
464 if (oshort (o) && ! find_char (o->key, hol->short_options, so))
465 /* O has a valid short option which hasn't already been used.*/
469 while (! oend (o) && oalias (o));
471 *so = '\0'; /* null terminated so we can find the length */
477 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
478 associated argp child list entry), INDEX, and PARENT, and return a pointer
479 to it. ARGP is the argp that this cluster results from. */
480 static struct hol_cluster *
481 hol_add_cluster (struct hol *hol, int group, const char *header, int index,
482 struct hol_cluster *parent, const struct argp *argp)
484 struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));
493 cl->depth = parent ? parent->depth + 1 : 0;
495 cl->next = hol->clusters;
501 /* Free HOL and any resources it uses. */
503 hol_free (struct hol *hol)
505 struct hol_cluster *cl = hol->clusters;
509 struct hol_cluster *next = cl->next;
514 if (hol->num_entries > 0)
517 free (hol->short_options);
524 hol_entry_short_iterate (const struct hol_entry *entry,
525 int (*func)(const struct argp_option *opt,
526 const struct argp_option *real,
527 const char *domain, void *cookie),
528 const char *domain, void *cookie)
532 const struct argp_option *opt, *real = entry->opt;
533 char *so = entry->short_options;
535 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
536 if (oshort (opt) && *so == opt->key)
541 val = (*func)(opt, real, domain, cookie);
549 __attribute__ ((always_inline))
550 hol_entry_long_iterate (const struct hol_entry *entry,
551 int (*func)(const struct argp_option *opt,
552 const struct argp_option *real,
553 const char *domain, void *cookie),
554 const char *domain, void *cookie)
558 const struct argp_option *opt, *real = entry->opt;
560 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
566 val = (*func)(opt, real, domain, cookie);
572 /* Iterator that returns true for the first short option. */
574 until_short (const struct argp_option *opt, const struct argp_option *real,
575 const char *domain, void *cookie)
577 return oshort (opt) ? opt->key : 0;
580 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
582 hol_entry_first_short (const struct hol_entry *entry)
584 return hol_entry_short_iterate (entry, until_short,
585 entry->argp->argp_domain, 0);
588 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
590 hol_entry_first_long (const struct hol_entry *entry)
592 const struct argp_option *opt;
594 for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
595 if (opt->name && ovisible (opt))
600 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
602 static struct hol_entry *
603 hol_find_entry (struct hol *hol, const char *name)
605 struct hol_entry *entry = hol->entries;
606 unsigned num_entries = hol->num_entries;
608 while (num_entries-- > 0)
610 const struct argp_option *opt = entry->opt;
611 unsigned num_opts = entry->num;
613 while (num_opts-- > 0)
614 if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
625 /* If an entry with the long option NAME occurs in HOL, set it's special
626 sort position to GROUP. */
628 hol_set_group (struct hol *hol, const char *name, int group)
630 struct hol_entry *entry = hol_find_entry (hol, name);
632 entry->group = group;
635 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
636 EQ is what to return if GROUP1 and GROUP2 are the same. */
638 group_cmp (int group1, int group2, int eq)
640 if (group1 == group2)
642 else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
643 return group1 - group2;
645 return group2 - group1;
648 /* Compare clusters CL1 & CL2 by the order that they should appear in
651 hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
653 /* If one cluster is deeper than the other, use its ancestor at the same
654 level, so that finding the common ancestor is straightforward. */
655 while (cl1->depth < cl2->depth)
657 while (cl2->depth < cl1->depth)
660 /* Now reduce both clusters to their ancestors at the point where both have
661 a common parent; these can be directly compared. */
662 while (cl1->parent != cl2->parent)
663 cl1 = cl1->parent, cl2 = cl2->parent;
665 return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
668 /* Return the ancestor of CL that's just below the root (i.e., has a parent
670 static struct hol_cluster *
671 hol_cluster_base (struct hol_cluster *cl)
678 /* Return true if CL1 is a child of CL2. */
680 hol_cluster_is_child (const struct hol_cluster *cl1,
681 const struct hol_cluster *cl2)
683 while (cl1 && cl1 != cl2)
688 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
689 that should be used for comparisons, and returns true iff it should be
690 treated as a non-option. */
692 canon_doc_option (const char **name)
695 /* Skip initial whitespace. */
696 while (isspace (**name))
698 /* Decide whether this looks like an option (leading `-') or not. */
699 non_opt = (**name != '-');
700 /* Skip until part of name used for sorting. */
701 while (**name && !isalnum (**name))
706 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
709 hol_entry_cmp (const struct hol_entry *entry1,
710 const struct hol_entry *entry2)
712 /* The group numbers by which the entries should be ordered; if either is
713 in a cluster, then this is just the group within the cluster. */
714 int group1 = entry1->group, group2 = entry2->group;
716 if (entry1->cluster != entry2->cluster)
718 /* The entries are not within the same cluster, so we can't compare them
719 directly, we have to use the appropiate clustering level too. */
720 if (! entry1->cluster)
721 /* ENTRY1 is at the `base level', not in a cluster, so we have to
722 compare it's group number with that of the base cluster in which
723 ENTRY2 resides. Note that if they're in the same group, the
724 clustered option always comes laster. */
725 return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
726 else if (! entry2->cluster)
727 /* Likewise, but ENTRY2's not in a cluster. */
728 return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
730 /* Both entries are in clusters, we can just compare the clusters. */
731 return hol_cluster_cmp (entry1->cluster, entry2->cluster);
733 else if (group1 == group2)
734 /* The entries are both in the same cluster and group, so compare them
737 int short1 = hol_entry_first_short (entry1);
738 int short2 = hol_entry_first_short (entry2);
739 int doc1 = odoc (entry1->opt);
740 int doc2 = odoc (entry2->opt);
741 const char *long1 = hol_entry_first_long (entry1);
742 const char *long2 = hol_entry_first_long (entry2);
745 doc1 = canon_doc_option (&long1);
747 doc2 = canon_doc_option (&long2);
750 /* `documentation' options always follow normal options (or
751 documentation options that *look* like normal options). */
753 else if (!short1 && !short2 && long1 && long2)
754 /* Only long options. */
755 return __strcasecmp (long1, long2);
757 /* Compare short/short, long/short, short/long, using the first
758 character of long options. Entries without *any* valid
759 options (such as options with OPTION_HIDDEN set) will be put
760 first, but as they're not displayed, it doesn't matter where
763 char first1 = short1 ? short1 : long1 ? *long1 : 0;
764 char first2 = short2 ? short2 : long2 ? *long2 : 0;
766 int lower_cmp = _tolower (first1) - _tolower (first2);
768 int lower_cmp = tolower (first1) - tolower (first2);
770 /* Compare ignoring case, except when the options are both the
771 same letter, in which case lower-case always comes first. */
772 return lower_cmp ? lower_cmp : first2 - first1;
776 /* Within the same cluster, but not the same group, so just compare
778 return group_cmp (group1, group2, 0);
781 /* Version of hol_entry_cmp with correct signature for qsort. */
783 hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
785 return hol_entry_cmp (entry1_v, entry2_v);
788 /* Sort HOL by group and alphabetically by option name (with short options
789 taking precedence over long). Since the sorting is for display purposes
790 only, the shadowing of options isn't effected. */
792 hol_sort (struct hol *hol)
794 if (hol->num_entries > 0)
795 qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
799 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
800 any in MORE with the same name. */
802 hol_append (struct hol *hol, struct hol *more)
804 struct hol_cluster **cl_end = &hol->clusters;
806 /* Steal MORE's cluster list, and add it to the end of HOL's. */
808 cl_end = &(*cl_end)->next;
809 *cl_end = more->clusters;
813 if (more->num_entries > 0)
815 if (hol->num_entries == 0)
817 hol->num_entries = more->num_entries;
818 hol->entries = more->entries;
819 hol->short_options = more->short_options;
820 more->num_entries = 0; /* Mark MORE's fields as invalid. */
823 /* Append the entries in MORE to those in HOL, taking care to only add
824 non-shadowed SHORT_OPTIONS values. */
829 unsigned num_entries = hol->num_entries + more->num_entries;
830 struct hol_entry *entries =
831 malloc (num_entries * sizeof (struct hol_entry));
832 unsigned hol_so_len = strlen (hol->short_options);
833 char *short_options =
834 malloc (hol_so_len + strlen (more->short_options) + 1);
836 assert (entries && short_options);
837 if (SIZE_MAX <= UINT_MAX)
838 assert (num_entries <= SIZE_MAX / sizeof (struct hol_entry));
840 __mempcpy (__mempcpy (entries, hol->entries,
841 hol->num_entries * sizeof (struct hol_entry)),
843 more->num_entries * sizeof (struct hol_entry));
845 __mempcpy (short_options, hol->short_options, hol_so_len);
847 /* Fix up the short options pointers from HOL. */
848 for (e = entries, left = hol->num_entries; left > 0; e++, left--)
849 e->short_options += (short_options - hol->short_options);
851 /* Now add the short options from MORE, fixing up its entries
853 so = short_options + hol_so_len;
854 more_so = more->short_options;
855 for (left = more->num_entries; left > 0; e++, left--)
858 const struct argp_option *opt;
860 e->short_options = so;
862 for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
865 if (oshort (opt) && ch == opt->key)
866 /* The next short option in MORE_SO, CH, is from OPT. */
868 if (! find_char (ch, short_options,
869 short_options + hol_so_len))
870 /* The short option CH isn't shadowed by HOL's options,
871 so add it to the sum. */
881 free (hol->short_options);
883 hol->entries = entries;
884 hol->num_entries = num_entries;
885 hol->short_options = short_options;
892 /* Inserts enough spaces to make sure STREAM is at column COL. */
894 indent_to (argp_fmtstream_t stream, unsigned col)
896 int needed = col - __argp_fmtstream_point (stream);
898 __argp_fmtstream_putc (stream, ' ');
901 /* Output to STREAM either a space, or a newline if there isn't room for at
902 least ENSURE characters before the right margin. */
904 space (argp_fmtstream_t stream, size_t ensure)
906 if (__argp_fmtstream_point (stream) + ensure
907 >= __argp_fmtstream_rmargin (stream))
908 __argp_fmtstream_putc (stream, '\n');
910 __argp_fmtstream_putc (stream, ' ');
913 /* If the option REAL has an argument, we print it in using the printf
914 format REQ_FMT or OPT_FMT depending on whether it's a required or
915 optional argument. */
917 arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
918 const char *domain, argp_fmtstream_t stream)
922 if (real->flags & OPTION_ARG_OPTIONAL)
923 __argp_fmtstream_printf (stream, opt_fmt,
924 dgettext (domain, real->arg));
926 __argp_fmtstream_printf (stream, req_fmt,
927 dgettext (domain, real->arg));
931 /* Helper functions for hol_entry_help. */
933 /* State used during the execution of hol_help. */
934 struct hol_help_state
936 /* PREV_ENTRY should contain the previous entry printed, or 0. */
937 struct hol_entry *prev_entry;
939 /* If an entry is in a different group from the previous one, and SEP_GROUPS
940 is true, then a blank line will be printed before any output. */
943 /* True if a duplicate option argument was suppressed (only ever set if
944 UPARAMS.dup_args is false). */
945 int suppressed_dup_arg;
948 /* Some state used while printing a help entry (used to communicate with
949 helper functions). See the doc for hol_entry_help for more info, as most
950 of the fields are copied from its arguments. */
953 const struct hol_entry *entry;
954 argp_fmtstream_t stream;
955 struct hol_help_state *hhstate;
957 /* True if nothing's been printed so far. */
960 /* If non-zero, the state that was used to print this help. */
961 const struct argp_state *state;
964 /* If a user doc filter should be applied to DOC, do so. */
966 filter_doc (const char *doc, int key, const struct argp *argp,
967 const struct argp_state *state)
969 if (argp->help_filter)
970 /* We must apply a user filter to this output. */
972 void *input = __argp_input (argp, state);
973 return (*argp->help_filter) (key, doc, input);
980 /* Prints STR as a header line, with the margin lines set appropiately, and
981 notes the fact that groups should be separated with a blank line. ARGP is
982 the argp that should dictate any user doc filtering to take place. Note
983 that the previous wrap margin isn't restored, but the left margin is reset
986 print_header (const char *str, const struct argp *argp,
987 struct pentry_state *pest)
989 const char *tstr = dgettext (argp->argp_domain, str);
990 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
996 if (pest->hhstate->prev_entry)
997 /* Precede with a blank line. */
998 __argp_fmtstream_putc (pest->stream, '\n');
999 indent_to (pest->stream, uparams.header_col);
1000 __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
1001 __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
1002 __argp_fmtstream_puts (pest->stream, fstr);
1003 __argp_fmtstream_set_lmargin (pest->stream, 0);
1004 __argp_fmtstream_putc (pest->stream, '\n');
1007 pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
1011 free ((char *) fstr);
1014 /* Inserts a comma if this isn't the first item on the line, and then makes
1015 sure we're at least to column COL. If this *is* the first item on a line,
1016 prints any pending whitespace/headers that should precede this line. Also
1019 comma (unsigned col, struct pentry_state *pest)
1023 const struct hol_entry *pe = pest->hhstate->prev_entry;
1024 const struct hol_cluster *cl = pest->entry->cluster;
1026 if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
1027 __argp_fmtstream_putc (pest->stream, '\n');
1029 if (cl && cl->header && *cl->header
1031 || (pe->cluster != cl
1032 && !hol_cluster_is_child (pe->cluster, cl))))
1033 /* If we're changing clusters, then this must be the start of the
1034 ENTRY's cluster unless that is an ancestor of the previous one
1035 (in which case we had just popped into a sub-cluster for a bit).
1036 If so, then print the cluster's header line. */
1038 int old_wm = __argp_fmtstream_wmargin (pest->stream);
1039 print_header (cl->header, cl->argp, pest);
1040 __argp_fmtstream_set_wmargin (pest->stream, old_wm);
1046 __argp_fmtstream_puts (pest->stream, ", ");
1048 indent_to (pest->stream, col);
1051 /* Print help for ENTRY to STREAM. */
1053 hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
1054 argp_fmtstream_t stream, struct hol_help_state *hhstate)
1057 const struct argp_option *real = entry->opt, *opt;
1058 char *so = entry->short_options;
1059 int have_long_opt = 0; /* We have any long options. */
1060 /* Saved margins. */
1061 int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
1062 int old_wm = __argp_fmtstream_wmargin (stream);
1063 /* PEST is a state block holding some of our variables that we'd like to
1064 share with helper functions. */
1065 struct pentry_state pest = { entry, stream, hhstate, 1, state };
1068 for (opt = real, num = entry->num; num > 0; opt++, num--)
1069 if (opt->name && ovisible (opt))
1075 /* First emit short options. */
1076 __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
1077 for (opt = real, num = entry->num; num > 0; opt++, num--)
1078 if (oshort (opt) && opt->key == *so)
1079 /* OPT has a valid (non shadowed) short option. */
1083 comma (uparams.short_opt_col, &pest);
1084 __argp_fmtstream_putc (stream, '-');
1085 __argp_fmtstream_putc (stream, *so);
1086 if (!have_long_opt || uparams.dup_args)
1087 arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
1089 hhstate->suppressed_dup_arg = 1;
1094 /* Now, long options. */
1096 /* A `documentation' option. */
1098 __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
1099 for (opt = real, num = entry->num; num > 0; opt++, num--)
1100 if (opt->name && ovisible (opt))
1102 comma (uparams.doc_opt_col, &pest);
1103 /* Calling gettext here isn't quite right, since sorting will
1104 have been done on the original; but documentation options
1105 should be pretty rare anyway... */
1106 __argp_fmtstream_puts (stream,
1107 dgettext (state->root_argp->argp_domain,
1112 /* A real long option. */
1114 int first_long_opt = 1;
1116 __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
1117 for (opt = real, num = entry->num; num > 0; opt++, num--)
1118 if (opt->name && ovisible (opt))
1120 comma (uparams.long_opt_col, &pest);
1121 __argp_fmtstream_printf (stream, "--%s", opt->name);
1122 if (first_long_opt || uparams.dup_args)
1123 arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
1126 hhstate->suppressed_dup_arg = 1;
1130 /* Next, documentation strings. */
1131 __argp_fmtstream_set_lmargin (stream, 0);
1135 /* Didn't print any switches, what's up? */
1136 if (!oshort (real) && !real->name)
1137 /* This is a group header, print it nicely. */
1138 print_header (real->doc, entry->argp, &pest);
1140 /* Just a totally shadowed option or null header; print nothing. */
1141 goto cleanup; /* Just return, after cleaning up. */
1145 const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
1147 const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
1150 unsigned int col = __argp_fmtstream_point (stream);
1152 __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
1153 __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
1155 if (col > (unsigned int) (uparams.opt_doc_col + 3))
1156 __argp_fmtstream_putc (stream, '\n');
1157 else if (col >= (unsigned int) uparams.opt_doc_col)
1158 __argp_fmtstream_puts (stream, " ");
1160 indent_to (stream, uparams.opt_doc_col);
1162 __argp_fmtstream_puts (stream, fstr);
1164 if (fstr && fstr != tstr)
1165 free ((char *) fstr);
1167 /* Reset the left margin. */
1168 __argp_fmtstream_set_lmargin (stream, 0);
1169 __argp_fmtstream_putc (stream, '\n');
1172 hhstate->prev_entry = entry;
1175 __argp_fmtstream_set_lmargin (stream, old_lm);
1176 __argp_fmtstream_set_wmargin (stream, old_wm);
1179 /* Output a long help message about the options in HOL to STREAM. */
1181 hol_help (struct hol *hol, const struct argp_state *state,
1182 argp_fmtstream_t stream)
1185 struct hol_entry *entry;
1186 struct hol_help_state hhstate = { 0, 0, 0 };
1188 for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
1189 hol_entry_help (entry, state, stream, &hhstate);
1191 if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
1193 const char *tstr = dgettext (state->root_argp->argp_domain, "\
1194 Mandatory or optional arguments to long options are also mandatory or \
1195 optional for any corresponding short options.");
1196 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
1197 state ? state->root_argp : 0, state);
1200 __argp_fmtstream_putc (stream, '\n');
1201 __argp_fmtstream_puts (stream, fstr);
1202 __argp_fmtstream_putc (stream, '\n');
1204 if (fstr && fstr != tstr)
1205 free ((char *) fstr);
1209 /* Helper functions for hol_usage. */
1211 /* If OPT is a short option without an arg, append its key to the string
1212 pointer pointer to by COOKIE, and advance the pointer. */
1214 add_argless_short_opt (const struct argp_option *opt,
1215 const struct argp_option *real,
1216 const char *domain, void *cookie)
1218 char **snao_end = cookie;
1219 if (!(opt->arg || real->arg)
1220 && !((opt->flags | real->flags) & OPTION_NO_USAGE))
1221 *(*snao_end)++ = opt->key;
1225 /* If OPT is a short option with an arg, output a usage entry for it to the
1226 stream pointed at by COOKIE. */
1228 usage_argful_short_opt (const struct argp_option *opt,
1229 const struct argp_option *real,
1230 const char *domain, void *cookie)
1232 argp_fmtstream_t stream = cookie;
1233 const char *arg = opt->arg;
1234 int flags = opt->flags | real->flags;
1239 if (arg && !(flags & OPTION_NO_USAGE))
1241 arg = dgettext (domain, arg);
1243 if (flags & OPTION_ARG_OPTIONAL)
1244 __argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
1247 /* Manually do line wrapping so that it (probably) won't
1248 get wrapped at the embedded space. */
1249 space (stream, 6 + strlen (arg));
1250 __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
1257 /* Output a usage entry for the long option opt to the stream pointed at by
1260 usage_long_opt (const struct argp_option *opt,
1261 const struct argp_option *real,
1262 const char *domain, void *cookie)
1264 argp_fmtstream_t stream = cookie;
1265 const char *arg = opt->arg;
1266 int flags = opt->flags | real->flags;
1271 if (! (flags & OPTION_NO_USAGE))
1275 arg = dgettext (domain, arg);
1276 if (flags & OPTION_ARG_OPTIONAL)
1277 __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
1279 __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
1282 __argp_fmtstream_printf (stream, " [--%s]", opt->name);
1288 /* Print a short usage description for the arguments in HOL to STREAM. */
1290 hol_usage (struct hol *hol, argp_fmtstream_t stream)
1292 if (hol->num_entries > 0)
1295 struct hol_entry *entry;
1296 char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
1297 char *snao_end = short_no_arg_opts;
1299 /* First we put a list of short options without arguments. */
1300 for (entry = hol->entries, nentries = hol->num_entries
1302 ; entry++, nentries--)
1303 hol_entry_short_iterate (entry, add_argless_short_opt,
1304 entry->argp->argp_domain, &snao_end);
1305 if (snao_end > short_no_arg_opts)
1308 __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
1311 /* Now a list of short options *with* arguments. */
1312 for (entry = hol->entries, nentries = hol->num_entries
1314 ; entry++, nentries--)
1315 hol_entry_short_iterate (entry, usage_argful_short_opt,
1316 entry->argp->argp_domain, stream);
1318 /* Finally, a list of long options (whew!). */
1319 for (entry = hol->entries, nentries = hol->num_entries
1321 ; entry++, nentries--)
1322 hol_entry_long_iterate (entry, usage_long_opt,
1323 entry->argp->argp_domain, stream);
1327 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1328 cluster in which ARGP's entries should be clustered, or 0. */
1330 argp_hol (const struct argp *argp, struct hol_cluster *cluster)
1332 const struct argp_child *child = argp->children;
1333 struct hol *hol = make_hol (argp, cluster);
1337 struct hol_cluster *child_cluster =
1338 ((child->group || child->header)
1339 /* Put CHILD->argp within its own cluster. */
1340 ? hol_add_cluster (hol, child->group, child->header,
1341 child - argp->children, cluster, argp)
1342 /* Just merge it into the parent's cluster. */
1344 hol_append (hol, argp_hol (child->argp, child_cluster)) ;
1350 /* Calculate how many different levels with alternative args strings exist in
1353 argp_args_levels (const struct argp *argp)
1356 const struct argp_child *child = argp->children;
1358 if (argp->args_doc && strchr (argp->args_doc, '\n'))
1363 levels += argp_args_levels ((child++)->argp);
1368 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1369 preceded by a space. LEVELS is a pointer to a byte vector the length
1370 returned by argp_args_levels; it should be initialized to zero, and
1371 updated by this routine for the next call if ADVANCE is true. True is
1372 returned as long as there are more patterns to output. */
1374 argp_args_usage (const struct argp *argp, const struct argp_state *state,
1375 char **levels, int advance, argp_fmtstream_t stream)
1377 char *our_level = *levels;
1379 const struct argp_child *child = argp->children;
1380 const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
1381 const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
1385 const char *cp = fdoc;
1386 nl = __strchrnul (cp, '\n');
1388 /* This is a `multi-level' args doc; advance to the correct position
1389 as determined by our state in LEVELS, and update LEVELS. */
1393 for (i = 0; i < *our_level; i++)
1394 cp = nl + 1, nl = __strchrnul (cp, '\n');
1398 /* Manually do line wrapping so that it (probably) won't get wrapped at
1399 any embedded spaces. */
1400 space (stream, 1 + nl - cp);
1402 __argp_fmtstream_write (stream, cp, nl - cp);
1404 if (fdoc && fdoc != tdoc)
1405 free ((char *)fdoc); /* Free user's modified doc string. */
1409 advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
1411 if (advance && multiple)
1413 /* Need to increment our level. */
1415 /* There's more we can do here. */
1418 advance = 0; /* Our parent shouldn't advance also. */
1420 else if (*our_level > 0)
1421 /* We had multiple levels, but used them up; reset to zero. */
1428 /* Print the documentation for ARGP to STREAM; if POST is false, then
1429 everything preceeding a `\v' character in the documentation strings (or
1430 the whole string, for those with none) is printed, otherwise, everything
1431 following the `\v' character (nothing for strings without). Each separate
1432 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1433 then the first is as well. If FIRST_ONLY is true, only the first
1434 occurrence is output. Returns true if anything was output. */
1436 argp_doc (const struct argp *argp, const struct argp_state *state,
1437 int post, int pre_blank, int first_only,
1438 argp_fmtstream_t stream)
1441 const char *inp_text;
1444 size_t inp_text_limit = 0;
1445 const char *doc = dgettext (argp->argp_domain, argp->doc);
1446 const struct argp_child *child = argp->children;
1450 char *vt = strchr (doc, '\v');
1451 inp_text = post ? (vt ? vt + 1 : 0) : doc;
1452 inp_text_limit = (!post && vt) ? (vt - doc) : 0;
1457 if (argp->help_filter)
1458 /* We have to filter the doc strings. */
1461 /* Copy INP_TEXT so that it's nul-terminated. */
1462 inp_text = __strndup (inp_text, inp_text_limit);
1463 input = __argp_input (argp, state);
1465 (*argp->help_filter) (post
1466 ? ARGP_KEY_HELP_POST_DOC
1467 : ARGP_KEY_HELP_PRE_DOC,
1471 text = (const char *) inp_text;
1476 __argp_fmtstream_putc (stream, '\n');
1478 if (text == inp_text && inp_text_limit)
1479 __argp_fmtstream_write (stream, inp_text, inp_text_limit);
1481 __argp_fmtstream_puts (stream, text);
1483 if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
1484 __argp_fmtstream_putc (stream, '\n');
1489 if (text && text != inp_text)
1490 free ((char *) text); /* Free TEXT returned from the help filter. */
1491 if (inp_text && inp_text_limit && argp->help_filter)
1492 free ((char *) inp_text); /* We copied INP_TEXT, so free it now. */
1494 if (post && argp->help_filter)
1495 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1497 text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
1500 if (anything || pre_blank)
1501 __argp_fmtstream_putc (stream, '\n');
1502 __argp_fmtstream_puts (stream, text);
1503 free ((char *) text);
1504 if (__argp_fmtstream_point (stream)
1505 > __argp_fmtstream_lmargin (stream))
1506 __argp_fmtstream_putc (stream, '\n');
1512 while (child->argp && !(first_only && anything))
1514 argp_doc ((child++)->argp, state,
1515 post, anything || pre_blank, first_only,
1521 /* Output a usage message for ARGP to STREAM. If called from
1522 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1523 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1526 _help (const struct argp *argp, const struct argp_state *state, FILE *stream,
1527 unsigned flags, char *name)
1529 int anything = 0; /* Whether we've output anything. */
1530 struct hol *hol = 0;
1531 argp_fmtstream_t fs;
1536 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1537 __flockfile (stream);
1540 if (! uparams.valid)
1541 fill_in_uparams (state);
1543 fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
1546 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1547 __funlockfile (stream);
1552 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
1554 hol = argp_hol (argp, 0);
1556 /* If present, these options always come last. */
1557 hol_set_group (hol, "help", -1);
1558 hol_set_group (hol, "version", -1);
1563 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
1564 /* Print a short `Usage:' message. */
1566 int first_pattern = 1, more_patterns;
1567 size_t num_pattern_levels = argp_args_levels (argp);
1568 char *pattern_levels = alloca (num_pattern_levels);
1570 memset (pattern_levels, 0, num_pattern_levels);
1575 int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
1576 char *levels = pattern_levels;
1579 __argp_fmtstream_printf (fs, "%s %s",
1580 dgettext (argp->argp_domain, "Usage:"),
1583 __argp_fmtstream_printf (fs, "%s %s",
1584 dgettext (argp->argp_domain, " or: "),
1587 /* We set the lmargin as well as the wmargin, because hol_usage
1588 manually wraps options with newline to avoid annoying breaks. */
1589 old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
1591 if (flags & ARGP_HELP_SHORT_USAGE)
1592 /* Just show where the options go. */
1594 if (hol->num_entries > 0)
1595 __argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
1599 /* Actually print the options. */
1601 hol_usage (hol, fs);
1602 flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once. */
1605 more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
1607 __argp_fmtstream_set_wmargin (fs, old_wm);
1608 __argp_fmtstream_set_lmargin (fs, old_lm);
1610 __argp_fmtstream_putc (fs, '\n');
1615 while (more_patterns);
1618 if (flags & ARGP_HELP_PRE_DOC)
1619 anything |= argp_doc (argp, state, 0, 0, 1, fs);
1621 if (flags & ARGP_HELP_SEE)
1623 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
1624 Try `%s --help' or `%s --usage' for more information.\n"),
1629 if (flags & ARGP_HELP_LONG)
1630 /* Print a long, detailed help message. */
1632 /* Print info about all the options. */
1633 if (hol->num_entries > 0)
1636 __argp_fmtstream_putc (fs, '\n');
1637 hol_help (hol, state, fs);
1642 if (flags & ARGP_HELP_POST_DOC)
1643 /* Print any documentation strings at the end. */
1644 anything |= argp_doc (argp, state, 1, anything, 0, fs);
1646 if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
1649 __argp_fmtstream_putc (fs, '\n');
1650 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
1651 "Report bugs to %s.\n"),
1652 argp_program_bug_address);
1656 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1657 __funlockfile (stream);
1663 __argp_fmtstream_free (fs);
1666 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1667 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1668 void __argp_help (const struct argp *argp, FILE *stream,
1669 unsigned flags, char *name)
1671 _help (argp, 0, stream, flags, name);
1674 weak_alias (__argp_help, argp_help)
1677 #ifndef __argp_short_program_name
1678 char *__argp_basename (char *name)
1680 char *short_name = strrchr (name, '/');
1681 return short_name ? short_name + 1 : name;
1685 __argp_short_program_name (void)
1687 # if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
1688 return program_invocation_short_name;
1689 # elif HAVE_DECL_PROGRAM_INVOCATION_NAME
1690 return __argp_basename (program_invocation_name);
1692 /* FIXME: What now? Miles suggests that it is better to use NULL,
1693 but currently the value is passed on directly to fputs_unlocked,
1694 so that requires more changes. */
1696 # warning No reasonable value to return
1697 # endif /* __GNUC__ */
1703 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1704 from the set ARGP_HELP_*. */
1706 __argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
1708 if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
1710 if (state && (state->flags & ARGP_LONG_ONLY))
1711 flags |= ARGP_HELP_LONG_ONLY;
1713 _help (state ? state->root_argp : 0, state, stream, flags,
1714 state ? state->name : __argp_short_program_name ());
1716 if (!state || ! (state->flags & ARGP_NO_EXIT))
1718 if (flags & ARGP_HELP_EXIT_ERR)
1719 exit (argp_err_exit_status);
1720 if (flags & ARGP_HELP_EXIT_OK)
1726 weak_alias (__argp_state_help, argp_state_help)
1729 /* If appropriate, print the printf string FMT and following args, preceded
1730 by the program name and `:', to stderr, and followed by a `Try ... --help'
1731 message, then exit (1). */
1733 __argp_error (const struct argp_state *state, const char *fmt, ...)
1735 if (!state || !(state->flags & ARGP_NO_ERRS))
1737 FILE *stream = state ? state->err_stream : stderr;
1743 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1744 __flockfile (stream);
1750 if (_IO_fwide (stream, 0) > 0)
1754 __asprintf (&buf, fmt, ap);
1756 __fwprintf (stream, L"%s: %s\n",
1757 state ? state->name : __argp_short_program_name (),
1765 fputs_unlocked (state
1766 ? state->name : __argp_short_program_name (),
1768 putc_unlocked (':', stream);
1769 putc_unlocked (' ', stream);
1771 vfprintf (stream, fmt, ap);
1773 putc_unlocked ('\n', stream);
1776 __argp_state_help (state, stream, ARGP_HELP_STD_ERR);
1780 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1781 __funlockfile (stream);
1787 weak_alias (__argp_error, argp_error)
1790 /* Similar to the standard gnu error-reporting function error(), but will
1791 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1792 to STATE->err_stream. This is useful for argument parsing code that is
1793 shared between program startup (when exiting is desired) and runtime
1794 option parsing (when typically an error code is returned instead). The
1795 difference between this function and argp_error is that the latter is for
1796 *parsing errors*, and the former is for other problems that occur during
1797 parsing but don't reflect a (syntactic) problem with the input. */
1799 __argp_failure (const struct argp_state *state, int status, int errnum,
1800 const char *fmt, ...)
1802 if (!state || !(state->flags & ARGP_NO_ERRS))
1804 FILE *stream = state ? state->err_stream : stderr;
1808 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1809 __flockfile (stream);
1813 if (_IO_fwide (stream, 0) > 0)
1814 __fwprintf (stream, L"%s",
1815 state ? state->name : __argp_short_program_name ());
1818 fputs_unlocked (state
1819 ? state->name : __argp_short_program_name (),
1828 if (_IO_fwide (stream, 0) > 0)
1832 __asprintf (&buf, fmt, ap);
1834 __fwprintf (stream, L": %s", buf);
1841 putc_unlocked (':', stream);
1842 putc_unlocked (' ', stream);
1844 vfprintf (stream, fmt, ap);
1855 if (_IO_fwide (stream, 0) > 0)
1856 __fwprintf (stream, L": %s",
1857 __strerror_r (errnum, buf, sizeof (buf)));
1861 putc_unlocked (':', stream);
1862 putc_unlocked (' ', stream);
1863 #if defined _LIBC || defined HAVE_STRERROR_R
1864 fputs (__strerror_r (errnum, buf, sizeof (buf)), stream);
1866 fputs (strerror (errnum), stream);
1872 if (_IO_fwide (stream, 0) > 0)
1873 putwc_unlocked (L'\n', stream);
1876 putc_unlocked ('\n', stream);
1878 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1879 __funlockfile (stream);
1882 if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
1888 weak_alias (__argp_failure, argp_failure)