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
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 */
55 /* This is for other GNU distributions with internationalized messages. */
56 # if defined HAVE_LIBINTL_H || defined _LIBC
60 # define dgettext(domain, msgid) \
61 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
64 # define dgettext(domain, msgid) (msgid)
70 # if !HAVE_DECL_STRERROR_R
71 char *strerror_r (int errnum, char *buf, size_t buflen);
74 # if !HAVE_DECL_STRERROR
75 char *strerror (int errnum);
81 #include "argp-fmtstream.h"
82 #include "argp-namefrob.h"
85 # define SIZE_MAX ((size_t) -1)
88 /* User-selectable (using an environment variable) formatting parameters.
90 These may be specified in an environment variable called `ARGP_HELP_FMT',
91 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
92 Where VALn must be a positive integer. The list of variables is in the
93 UPARAM_NAMES vector, below. */
95 /* Default parameters. */
96 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
97 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
98 #define SHORT_OPT_COL 2 /* column in which short options start */
99 #define LONG_OPT_COL 6 /* column in which long options start */
100 #define DOC_OPT_COL 2 /* column in which doc options start */
101 #define OPT_DOC_COL 29 /* column in which option text starts */
102 #define HEADER_COL 1 /* column in which group headers are printed */
103 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
104 #define RMARGIN 79 /* right margin used for wrapping */
106 /* User-selectable (using an environment variable) formatting parameters.
107 They must all be of type `int' for the parsing code to work. */
110 /* If true, arguments for an option are shown with both short and long
111 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
112 If false, then if an option has both, the argument is only shown with
113 the long one, e.g., `-x, --longx=ARG', and a message indicating that
114 this really means both is printed below the options. */
117 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
118 been suppressed, an explanatory message should be printed. */
121 /* Various output columns. */
130 int valid; /* True when the values in here are valid. */
133 /* This is a global variable, as user options are only ever read once. */
134 static struct uparams uparams = {
135 DUP_ARGS, DUP_ARGS_NOTE,
136 SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,
137 USAGE_INDENT, RMARGIN,
141 /* A particular uparam, and what the user name is. */
144 const char *name; /* User name. */
145 int is_bool; /* Whether it's `boolean'. */
146 size_t uparams_offs; /* Location of the (int) field in UPARAMS. */
149 /* The name-field mappings we know about. */
150 static const struct uparam_name uparam_names[] =
152 { "dup-args", 1, offsetof (struct uparams, dup_args) },
153 { "dup-args-note", 1, offsetof (struct uparams, dup_args_note) },
154 { "short-opt-col", 0, offsetof (struct uparams, short_opt_col) },
155 { "long-opt-col", 0, offsetof (struct uparams, long_opt_col) },
156 { "doc-opt-col", 0, offsetof (struct uparams, doc_opt_col) },
157 { "opt-doc-col", 0, offsetof (struct uparams, opt_doc_col) },
158 { "header-col", 0, offsetof (struct uparams, header_col) },
159 { "usage-indent", 0, offsetof (struct uparams, usage_indent) },
160 { "rmargin", 0, offsetof (struct uparams, rmargin) },
164 /* Read user options from the environment, and fill in UPARAMS appropiately. */
166 fill_in_uparams (const struct argp_state *state)
168 const char *var = getenv ("ARGP_HELP_FMT");
170 #define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
181 const struct uparam_name *un;
182 int unspec = 0, val = 0;
183 const char *arg = var;
185 while (isalnum (*arg) || *arg == '-' || *arg == '_')
191 if (*arg == '\0' || *arg == ',')
193 else if (*arg == '=')
201 if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')
210 else if (isdigit (*arg))
213 while (isdigit (*arg))
218 for (un = uparam_names; un->name; un++)
219 if (strlen (un->name) == var_len
220 && strncmp (var, un->name, var_len) == 0)
222 if (unspec && !un->is_bool)
223 __argp_failure (state, 0, 0,
224 dgettext (state->root_argp->argp_domain, "\
225 %.*s: ARGP_HELP_FMT parameter requires a value"),
228 *(int *)((char *)&uparams + un->uparams_offs) = val;
232 __argp_failure (state, 0, 0,
233 dgettext (state->root_argp->argp_domain, "\
234 %.*s: Unknown ARGP_HELP_FMT parameter"),
243 __argp_failure (state, 0, 0,
244 dgettext (state->root_argp->argp_domain,
245 "Garbage in ARGP_HELP_FMT: %s"), var);
251 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
252 whether OPT is displayed or used in sorting, not option shadowing. */
253 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
255 /* Returns true if OPT is an alias for an earlier option. */
256 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
258 /* Returns true if OPT is an documentation-only entry. */
259 #define odoc(opt) ((opt)->flags & OPTION_DOC)
261 /* Returns true if OPT is the end-of-list marker for a list of options. */
262 #define oend(opt) __option_is_end (opt)
264 /* Returns true if OPT has a short option. */
265 #define oshort(opt) __option_is_short (opt)
268 The help format for a particular option is like:
270 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
272 Where ARG will be omitted if there's no argument, for this option, or
273 will be surrounded by "[" and "]" appropiately if the argument is
274 optional. The documentation string is word-wrapped appropiately, and if
275 the list of options is long enough, it will be started on a separate line.
276 If there are no short options for a given option, the first long option is
277 indented slighly in a way that's supposed to make most long options appear
278 to be in a separate column.
280 For example, the following output (from ps):
282 -p PID, --pid=PID List the process PID
283 --pgrp=PGRP List processes in the process group PGRP
284 -P, -x, --no-parent Include processes without parents
285 -Q, --all-fields Don't elide unusable fields (normally if there's
286 some reason ps can't print a field for any
287 process, it's removed from the output entirely)
288 -r, --reverse, --gratuitously-long-reverse-option
289 Reverse the order of any sort
290 --session[=SID] Add the processes from the session SID (which
291 defaults to the sid of the current process)
293 Here are some more options:
294 -f ZOT, --foonly=ZOT Glork a foonly
295 -z, --zaza Snit a zar
297 -?, --help Give this help list
298 --usage Give a short usage message
299 -V, --version Print program version
301 The struct argp_option array for the above could look like:
304 {"pid", 'p', "PID", 0, "List the process PID"},
305 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
306 {"no-parent", 'P', 0, 0, "Include processes without parents"},
307 {0, 'x', 0, OPTION_ALIAS},
308 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
309 " if there's some reason ps can't"
310 " print a field for any process, it's"
311 " removed from the output entirely)" },
312 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
313 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
314 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
315 "Add the processes from the session"
316 " SID (which defaults to the sid of"
317 " the current process)" },
319 {0,0,0,0, "Here are some more options:"},
320 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
321 {"zaza", 'z', 0, 0, "Snit a zar"},
326 Note that the last three options are automatically supplied by argp_parse,
327 unless you tell it not to with ARGP_NO_HELP.
331 /* Returns true if CH occurs between BEG and END. */
333 find_char (char ch, char *beg, char *end)
343 struct hol_cluster; /* fwd decl */
348 const struct argp_option *opt;
349 /* Number of options (including aliases). */
352 /* A pointers into the HOL's short_options field, to the first short option
353 letter for this entry. The order of the characters following this point
354 corresponds to the order of options pointed to by OPT, and there are at
355 most NUM. A short option recorded in a option following OPT is only
356 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
357 probably been shadowed by some other entry). */
360 /* Entries are sorted by their group first, in the order:
361 1, 2, ..., n, 0, -m, ..., -2, -1
362 and then alphabetically within each group. The default is 0. */
365 /* The cluster of options this entry belongs to, or 0 if none. */
366 struct hol_cluster *cluster;
368 /* The argp from which this option came. */
369 const struct argp *argp;
372 /* A cluster of entries to reflect the argp tree structure. */
375 /* A descriptive header printed before options in this cluster. */
378 /* Used to order clusters within the same group with the same parent,
379 according to the order in which they occurred in the parent argp's child
383 /* How to sort this cluster with respect to options and other clusters at the
384 same depth (clusters always follow options in the same group). */
387 /* The cluster to which this cluster belongs, or 0 if it's at the base
389 struct hol_cluster *parent;
391 /* The argp from which this cluster is (eventually) derived. */
392 const struct argp *argp;
394 /* The distance this cluster is from the root. */
397 /* Clusters in a given hol are kept in a linked list, to make freeing them
399 struct hol_cluster *next;
402 /* A list of options for help. */
405 /* An array of hol_entry's. */
406 struct hol_entry *entries;
407 /* The number of entries in this hol. If this field is zero, the others
409 unsigned num_entries;
411 /* A string containing all short options in this HOL. Each entry contains
412 pointers into this string, so the order can't be messed with blindly. */
415 /* Clusters of entries in this hol. */
416 struct hol_cluster *clusters;
419 /* Create a struct hol from the options in ARGP. CLUSTER is the
420 hol_cluster in which these entries occur, or 0, if at the root. */
422 make_hol (const struct argp *argp, struct hol_cluster *cluster)
425 const struct argp_option *o;
426 const struct argp_option *opts = argp->options;
427 struct hol_entry *entry;
428 unsigned num_short_options = 0;
429 struct hol *hol = malloc (sizeof (struct hol));
433 hol->num_entries = 0;
440 /* The first option must not be an alias. */
441 assert (! oalias (opts));
443 /* Calculate the space needed. */
444 for (o = opts; ! oend (o); o++)
449 num_short_options++; /* This is an upper bound. */
452 hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);
453 hol->short_options = malloc (num_short_options + 1);
455 assert (hol->entries && hol->short_options);
456 #if SIZE_MAX <= UINT_MAX
457 assert (hol->num_entries <= SIZE_MAX / sizeof (struct hol_entry));
460 /* Fill in the entries. */
461 so = hol->short_options;
462 for (o = opts, entry = hol->entries; ! oend (o); entry++)
466 entry->short_options = so;
467 entry->group = cur_group =
470 : ((!o->name && !o->key)
473 entry->cluster = cluster;
479 if (oshort (o) && ! find_char (o->key, hol->short_options, so))
480 /* O has a valid short option which hasn't already been used.*/
484 while (! oend (o) && oalias (o));
486 *so = '\0'; /* null terminated so we can find the length */
492 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
493 associated argp child list entry), INDEX, and PARENT, and return a pointer
494 to it. ARGP is the argp that this cluster results from. */
495 static struct hol_cluster *
496 hol_add_cluster (struct hol *hol, int group, const char *header, int index,
497 struct hol_cluster *parent, const struct argp *argp)
499 struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));
508 cl->depth = parent ? parent->depth + 1 : 0;
510 cl->next = hol->clusters;
516 /* Free HOL and any resources it uses. */
518 hol_free (struct hol *hol)
520 struct hol_cluster *cl = hol->clusters;
524 struct hol_cluster *next = cl->next;
529 if (hol->num_entries > 0)
532 free (hol->short_options);
539 hol_entry_short_iterate (const struct hol_entry *entry,
540 int (*func)(const struct argp_option *opt,
541 const struct argp_option *real,
542 const char *domain, void *cookie),
543 const char *domain, void *cookie)
547 const struct argp_option *opt, *real = entry->opt;
548 char *so = entry->short_options;
550 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
551 if (oshort (opt) && *so == opt->key)
556 val = (*func)(opt, real, domain, cookie);
564 __attribute__ ((always_inline))
565 hol_entry_long_iterate (const struct hol_entry *entry,
566 int (*func)(const struct argp_option *opt,
567 const struct argp_option *real,
568 const char *domain, void *cookie),
569 const char *domain, void *cookie)
573 const struct argp_option *opt, *real = entry->opt;
575 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
581 val = (*func)(opt, real, domain, cookie);
587 /* Iterator that returns true for the first short option. */
589 until_short (const struct argp_option *opt, const struct argp_option *real,
590 const char *domain, void *cookie)
592 return oshort (opt) ? opt->key : 0;
595 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
597 hol_entry_first_short (const struct hol_entry *entry)
599 return hol_entry_short_iterate (entry, until_short,
600 entry->argp->argp_domain, 0);
603 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
605 hol_entry_first_long (const struct hol_entry *entry)
607 const struct argp_option *opt;
609 for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
610 if (opt->name && ovisible (opt))
615 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
617 static struct hol_entry *
618 hol_find_entry (struct hol *hol, const char *name)
620 struct hol_entry *entry = hol->entries;
621 unsigned num_entries = hol->num_entries;
623 while (num_entries-- > 0)
625 const struct argp_option *opt = entry->opt;
626 unsigned num_opts = entry->num;
628 while (num_opts-- > 0)
629 if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
640 /* If an entry with the long option NAME occurs in HOL, set it's special
641 sort position to GROUP. */
643 hol_set_group (struct hol *hol, const char *name, int group)
645 struct hol_entry *entry = hol_find_entry (hol, name);
647 entry->group = group;
650 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
651 EQ is what to return if GROUP1 and GROUP2 are the same. */
653 group_cmp (int group1, int group2, int eq)
655 if (group1 == group2)
657 else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
658 return group1 - group2;
660 return group2 - group1;
663 /* Compare clusters CL1 & CL2 by the order that they should appear in
666 hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
668 /* If one cluster is deeper than the other, use its ancestor at the same
669 level, so that finding the common ancestor is straightforward. */
670 while (cl1->depth < cl2->depth)
672 while (cl2->depth < cl1->depth)
675 /* Now reduce both clusters to their ancestors at the point where both have
676 a common parent; these can be directly compared. */
677 while (cl1->parent != cl2->parent)
678 cl1 = cl1->parent, cl2 = cl2->parent;
680 return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
683 /* Return the ancestor of CL that's just below the root (i.e., has a parent
685 static struct hol_cluster *
686 hol_cluster_base (struct hol_cluster *cl)
693 /* Return true if CL1 is a child of CL2. */
695 hol_cluster_is_child (const struct hol_cluster *cl1,
696 const struct hol_cluster *cl2)
698 while (cl1 && cl1 != cl2)
703 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
704 that should be used for comparisons, and returns true iff it should be
705 treated as a non-option. */
707 canon_doc_option (const char **name)
710 /* Skip initial whitespace. */
711 while (isspace (**name))
713 /* Decide whether this looks like an option (leading `-') or not. */
714 non_opt = (**name != '-');
715 /* Skip until part of name used for sorting. */
716 while (**name && !isalnum (**name))
721 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
724 hol_entry_cmp (const struct hol_entry *entry1,
725 const struct hol_entry *entry2)
727 /* The group numbers by which the entries should be ordered; if either is
728 in a cluster, then this is just the group within the cluster. */
729 int group1 = entry1->group, group2 = entry2->group;
731 if (entry1->cluster != entry2->cluster)
733 /* The entries are not within the same cluster, so we can't compare them
734 directly, we have to use the appropiate clustering level too. */
735 if (! entry1->cluster)
736 /* ENTRY1 is at the `base level', not in a cluster, so we have to
737 compare it's group number with that of the base cluster in which
738 ENTRY2 resides. Note that if they're in the same group, the
739 clustered option always comes laster. */
740 return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
741 else if (! entry2->cluster)
742 /* Likewise, but ENTRY2's not in a cluster. */
743 return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
745 /* Both entries are in clusters, we can just compare the clusters. */
746 return hol_cluster_cmp (entry1->cluster, entry2->cluster);
748 else if (group1 == group2)
749 /* The entries are both in the same cluster and group, so compare them
752 int short1 = hol_entry_first_short (entry1);
753 int short2 = hol_entry_first_short (entry2);
754 int doc1 = odoc (entry1->opt);
755 int doc2 = odoc (entry2->opt);
756 const char *long1 = hol_entry_first_long (entry1);
757 const char *long2 = hol_entry_first_long (entry2);
760 doc1 = canon_doc_option (&long1);
762 doc2 = canon_doc_option (&long2);
765 /* `documentation' options always follow normal options (or
766 documentation options that *look* like normal options). */
768 else if (!short1 && !short2 && long1 && long2)
769 /* Only long options. */
770 return __strcasecmp (long1, long2);
772 /* Compare short/short, long/short, short/long, using the first
773 character of long options. Entries without *any* valid
774 options (such as options with OPTION_HIDDEN set) will be put
775 first, but as they're not displayed, it doesn't matter where
778 char first1 = short1 ? short1 : long1 ? *long1 : 0;
779 char first2 = short2 ? short2 : long2 ? *long2 : 0;
781 int lower_cmp = _tolower (first1) - _tolower (first2);
783 int lower_cmp = tolower (first1) - tolower (first2);
785 /* Compare ignoring case, except when the options are both the
786 same letter, in which case lower-case always comes first. */
787 return lower_cmp ? lower_cmp : first2 - first1;
791 /* Within the same cluster, but not the same group, so just compare
793 return group_cmp (group1, group2, 0);
796 /* Version of hol_entry_cmp with correct signature for qsort. */
798 hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
800 return hol_entry_cmp (entry1_v, entry2_v);
803 /* Sort HOL by group and alphabetically by option name (with short options
804 taking precedence over long). Since the sorting is for display purposes
805 only, the shadowing of options isn't effected. */
807 hol_sort (struct hol *hol)
809 if (hol->num_entries > 0)
810 qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
814 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
815 any in MORE with the same name. */
817 hol_append (struct hol *hol, struct hol *more)
819 struct hol_cluster **cl_end = &hol->clusters;
821 /* Steal MORE's cluster list, and add it to the end of HOL's. */
823 cl_end = &(*cl_end)->next;
824 *cl_end = more->clusters;
828 if (more->num_entries > 0)
830 if (hol->num_entries == 0)
832 hol->num_entries = more->num_entries;
833 hol->entries = more->entries;
834 hol->short_options = more->short_options;
835 more->num_entries = 0; /* Mark MORE's fields as invalid. */
838 /* Append the entries in MORE to those in HOL, taking care to only add
839 non-shadowed SHORT_OPTIONS values. */
844 unsigned num_entries = hol->num_entries + more->num_entries;
845 struct hol_entry *entries =
846 malloc (num_entries * sizeof (struct hol_entry));
847 unsigned hol_so_len = strlen (hol->short_options);
848 char *short_options =
849 malloc (hol_so_len + strlen (more->short_options) + 1);
851 assert (entries && short_options);
852 #if SIZE_MAX <= UINT_MAX
853 assert (num_entries <= SIZE_MAX / sizeof (struct hol_entry));
856 __mempcpy (__mempcpy (entries, hol->entries,
857 hol->num_entries * sizeof (struct hol_entry)),
859 more->num_entries * sizeof (struct hol_entry));
861 __mempcpy (short_options, hol->short_options, hol_so_len);
863 /* Fix up the short options pointers from HOL. */
864 for (e = entries, left = hol->num_entries; left > 0; e++, left--)
865 e->short_options += (short_options - hol->short_options);
867 /* Now add the short options from MORE, fixing up its entries
869 so = short_options + hol_so_len;
870 more_so = more->short_options;
871 for (left = more->num_entries; left > 0; e++, left--)
874 const struct argp_option *opt;
876 e->short_options = so;
878 for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
881 if (oshort (opt) && ch == opt->key)
882 /* The next short option in MORE_SO, CH, is from OPT. */
884 if (! find_char (ch, short_options,
885 short_options + hol_so_len))
886 /* The short option CH isn't shadowed by HOL's options,
887 so add it to the sum. */
897 free (hol->short_options);
899 hol->entries = entries;
900 hol->num_entries = num_entries;
901 hol->short_options = short_options;
908 /* Inserts enough spaces to make sure STREAM is at column COL. */
910 indent_to (argp_fmtstream_t stream, unsigned col)
912 int needed = col - __argp_fmtstream_point (stream);
914 __argp_fmtstream_putc (stream, ' ');
917 /* Output to STREAM either a space, or a newline if there isn't room for at
918 least ENSURE characters before the right margin. */
920 space (argp_fmtstream_t stream, size_t ensure)
922 if (__argp_fmtstream_point (stream) + ensure
923 >= __argp_fmtstream_rmargin (stream))
924 __argp_fmtstream_putc (stream, '\n');
926 __argp_fmtstream_putc (stream, ' ');
929 /* If the option REAL has an argument, we print it in using the printf
930 format REQ_FMT or OPT_FMT depending on whether it's a required or
931 optional argument. */
933 arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
934 const char *domain, argp_fmtstream_t stream)
938 if (real->flags & OPTION_ARG_OPTIONAL)
939 __argp_fmtstream_printf (stream, opt_fmt,
940 dgettext (domain, real->arg));
942 __argp_fmtstream_printf (stream, req_fmt,
943 dgettext (domain, real->arg));
947 /* Helper functions for hol_entry_help. */
949 /* State used during the execution of hol_help. */
950 struct hol_help_state
952 /* PREV_ENTRY should contain the previous entry printed, or 0. */
953 struct hol_entry *prev_entry;
955 /* If an entry is in a different group from the previous one, and SEP_GROUPS
956 is true, then a blank line will be printed before any output. */
959 /* True if a duplicate option argument was suppressed (only ever set if
960 UPARAMS.dup_args is false). */
961 int suppressed_dup_arg;
964 /* Some state used while printing a help entry (used to communicate with
965 helper functions). See the doc for hol_entry_help for more info, as most
966 of the fields are copied from its arguments. */
969 const struct hol_entry *entry;
970 argp_fmtstream_t stream;
971 struct hol_help_state *hhstate;
973 /* True if nothing's been printed so far. */
976 /* If non-zero, the state that was used to print this help. */
977 const struct argp_state *state;
980 /* If a user doc filter should be applied to DOC, do so. */
982 filter_doc (const char *doc, int key, const struct argp *argp,
983 const struct argp_state *state)
985 if (argp->help_filter)
986 /* We must apply a user filter to this output. */
988 void *input = __argp_input (argp, state);
989 return (*argp->help_filter) (key, doc, input);
996 /* Prints STR as a header line, with the margin lines set appropiately, and
997 notes the fact that groups should be separated with a blank line. ARGP is
998 the argp that should dictate any user doc filtering to take place. Note
999 that the previous wrap margin isn't restored, but the left margin is reset
1002 print_header (const char *str, const struct argp *argp,
1003 struct pentry_state *pest)
1005 const char *tstr = dgettext (argp->argp_domain, str);
1006 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
1012 if (pest->hhstate->prev_entry)
1013 /* Precede with a blank line. */
1014 __argp_fmtstream_putc (pest->stream, '\n');
1015 indent_to (pest->stream, uparams.header_col);
1016 __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
1017 __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
1018 __argp_fmtstream_puts (pest->stream, fstr);
1019 __argp_fmtstream_set_lmargin (pest->stream, 0);
1020 __argp_fmtstream_putc (pest->stream, '\n');
1023 pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
1027 free ((char *) fstr);
1030 /* Inserts a comma if this isn't the first item on the line, and then makes
1031 sure we're at least to column COL. If this *is* the first item on a line,
1032 prints any pending whitespace/headers that should precede this line. Also
1035 comma (unsigned col, struct pentry_state *pest)
1039 const struct hol_entry *pe = pest->hhstate->prev_entry;
1040 const struct hol_cluster *cl = pest->entry->cluster;
1042 if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
1043 __argp_fmtstream_putc (pest->stream, '\n');
1045 if (cl && cl->header && *cl->header
1047 || (pe->cluster != cl
1048 && !hol_cluster_is_child (pe->cluster, cl))))
1049 /* If we're changing clusters, then this must be the start of the
1050 ENTRY's cluster unless that is an ancestor of the previous one
1051 (in which case we had just popped into a sub-cluster for a bit).
1052 If so, then print the cluster's header line. */
1054 int old_wm = __argp_fmtstream_wmargin (pest->stream);
1055 print_header (cl->header, cl->argp, pest);
1056 __argp_fmtstream_set_wmargin (pest->stream, old_wm);
1062 __argp_fmtstream_puts (pest->stream, ", ");
1064 indent_to (pest->stream, col);
1067 /* Print help for ENTRY to STREAM. */
1069 hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
1070 argp_fmtstream_t stream, struct hol_help_state *hhstate)
1073 const struct argp_option *real = entry->opt, *opt;
1074 char *so = entry->short_options;
1075 int have_long_opt = 0; /* We have any long options. */
1076 /* Saved margins. */
1077 int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
1078 int old_wm = __argp_fmtstream_wmargin (stream);
1079 /* PEST is a state block holding some of our variables that we'd like to
1080 share with helper functions. */
1081 struct pentry_state pest = { entry, stream, hhstate, 1, state };
1084 for (opt = real, num = entry->num; num > 0; opt++, num--)
1085 if (opt->name && ovisible (opt))
1091 /* First emit short options. */
1092 __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
1093 for (opt = real, num = entry->num; num > 0; opt++, num--)
1094 if (oshort (opt) && opt->key == *so)
1095 /* OPT has a valid (non shadowed) short option. */
1099 comma (uparams.short_opt_col, &pest);
1100 __argp_fmtstream_putc (stream, '-');
1101 __argp_fmtstream_putc (stream, *so);
1102 if (!have_long_opt || uparams.dup_args)
1103 arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
1105 hhstate->suppressed_dup_arg = 1;
1110 /* Now, long options. */
1112 /* A `documentation' option. */
1114 __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
1115 for (opt = real, num = entry->num; num > 0; opt++, num--)
1116 if (opt->name && ovisible (opt))
1118 comma (uparams.doc_opt_col, &pest);
1119 /* Calling gettext here isn't quite right, since sorting will
1120 have been done on the original; but documentation options
1121 should be pretty rare anyway... */
1122 __argp_fmtstream_puts (stream,
1123 dgettext (state->root_argp->argp_domain,
1128 /* A real long option. */
1130 int first_long_opt = 1;
1132 __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
1133 for (opt = real, num = entry->num; num > 0; opt++, num--)
1134 if (opt->name && ovisible (opt))
1136 comma (uparams.long_opt_col, &pest);
1137 __argp_fmtstream_printf (stream, "--%s", opt->name);
1138 if (first_long_opt || uparams.dup_args)
1139 arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
1142 hhstate->suppressed_dup_arg = 1;
1146 /* Next, documentation strings. */
1147 __argp_fmtstream_set_lmargin (stream, 0);
1151 /* Didn't print any switches, what's up? */
1152 if (!oshort (real) && !real->name)
1153 /* This is a group header, print it nicely. */
1154 print_header (real->doc, entry->argp, &pest);
1156 /* Just a totally shadowed option or null header; print nothing. */
1157 goto cleanup; /* Just return, after cleaning up. */
1161 const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
1163 const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
1166 unsigned int col = __argp_fmtstream_point (stream);
1168 __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
1169 __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
1171 if (col > (unsigned int) (uparams.opt_doc_col + 3))
1172 __argp_fmtstream_putc (stream, '\n');
1173 else if (col >= (unsigned int) uparams.opt_doc_col)
1174 __argp_fmtstream_puts (stream, " ");
1176 indent_to (stream, uparams.opt_doc_col);
1178 __argp_fmtstream_puts (stream, fstr);
1180 if (fstr && fstr != tstr)
1181 free ((char *) fstr);
1183 /* Reset the left margin. */
1184 __argp_fmtstream_set_lmargin (stream, 0);
1185 __argp_fmtstream_putc (stream, '\n');
1188 hhstate->prev_entry = entry;
1191 __argp_fmtstream_set_lmargin (stream, old_lm);
1192 __argp_fmtstream_set_wmargin (stream, old_wm);
1195 /* Output a long help message about the options in HOL to STREAM. */
1197 hol_help (struct hol *hol, const struct argp_state *state,
1198 argp_fmtstream_t stream)
1201 struct hol_entry *entry;
1202 struct hol_help_state hhstate = { 0, 0, 0 };
1204 for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
1205 hol_entry_help (entry, state, stream, &hhstate);
1207 if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
1209 const char *tstr = dgettext (state->root_argp->argp_domain, "\
1210 Mandatory or optional arguments to long options are also mandatory or \
1211 optional for any corresponding short options.");
1212 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
1213 state ? state->root_argp : 0, state);
1216 __argp_fmtstream_putc (stream, '\n');
1217 __argp_fmtstream_puts (stream, fstr);
1218 __argp_fmtstream_putc (stream, '\n');
1220 if (fstr && fstr != tstr)
1221 free ((char *) fstr);
1225 /* Helper functions for hol_usage. */
1227 /* If OPT is a short option without an arg, append its key to the string
1228 pointer pointer to by COOKIE, and advance the pointer. */
1230 add_argless_short_opt (const struct argp_option *opt,
1231 const struct argp_option *real,
1232 const char *domain, void *cookie)
1234 char **snao_end = cookie;
1235 if (!(opt->arg || real->arg)
1236 && !((opt->flags | real->flags) & OPTION_NO_USAGE))
1237 *(*snao_end)++ = opt->key;
1241 /* If OPT is a short option with an arg, output a usage entry for it to the
1242 stream pointed at by COOKIE. */
1244 usage_argful_short_opt (const struct argp_option *opt,
1245 const struct argp_option *real,
1246 const char *domain, void *cookie)
1248 argp_fmtstream_t stream = cookie;
1249 const char *arg = opt->arg;
1250 int flags = opt->flags | real->flags;
1255 if (arg && !(flags & OPTION_NO_USAGE))
1257 arg = dgettext (domain, arg);
1259 if (flags & OPTION_ARG_OPTIONAL)
1260 __argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
1263 /* Manually do line wrapping so that it (probably) won't
1264 get wrapped at the embedded space. */
1265 space (stream, 6 + strlen (arg));
1266 __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
1273 /* Output a usage entry for the long option opt to the stream pointed at by
1276 usage_long_opt (const struct argp_option *opt,
1277 const struct argp_option *real,
1278 const char *domain, void *cookie)
1280 argp_fmtstream_t stream = cookie;
1281 const char *arg = opt->arg;
1282 int flags = opt->flags | real->flags;
1287 if (! (flags & OPTION_NO_USAGE))
1291 arg = dgettext (domain, arg);
1292 if (flags & OPTION_ARG_OPTIONAL)
1293 __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
1295 __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
1298 __argp_fmtstream_printf (stream, " [--%s]", opt->name);
1304 /* Print a short usage description for the arguments in HOL to STREAM. */
1306 hol_usage (struct hol *hol, argp_fmtstream_t stream)
1308 if (hol->num_entries > 0)
1311 struct hol_entry *entry;
1312 char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
1313 char *snao_end = short_no_arg_opts;
1315 /* First we put a list of short options without arguments. */
1316 for (entry = hol->entries, nentries = hol->num_entries
1318 ; entry++, nentries--)
1319 hol_entry_short_iterate (entry, add_argless_short_opt,
1320 entry->argp->argp_domain, &snao_end);
1321 if (snao_end > short_no_arg_opts)
1324 __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
1327 /* Now a list of short options *with* arguments. */
1328 for (entry = hol->entries, nentries = hol->num_entries
1330 ; entry++, nentries--)
1331 hol_entry_short_iterate (entry, usage_argful_short_opt,
1332 entry->argp->argp_domain, stream);
1334 /* Finally, a list of long options (whew!). */
1335 for (entry = hol->entries, nentries = hol->num_entries
1337 ; entry++, nentries--)
1338 hol_entry_long_iterate (entry, usage_long_opt,
1339 entry->argp->argp_domain, stream);
1343 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1344 cluster in which ARGP's entries should be clustered, or 0. */
1346 argp_hol (const struct argp *argp, struct hol_cluster *cluster)
1348 const struct argp_child *child = argp->children;
1349 struct hol *hol = make_hol (argp, cluster);
1353 struct hol_cluster *child_cluster =
1354 ((child->group || child->header)
1355 /* Put CHILD->argp within its own cluster. */
1356 ? hol_add_cluster (hol, child->group, child->header,
1357 child - argp->children, cluster, argp)
1358 /* Just merge it into the parent's cluster. */
1360 hol_append (hol, argp_hol (child->argp, child_cluster)) ;
1366 /* Calculate how many different levels with alternative args strings exist in
1369 argp_args_levels (const struct argp *argp)
1372 const struct argp_child *child = argp->children;
1374 if (argp->args_doc && strchr (argp->args_doc, '\n'))
1379 levels += argp_args_levels ((child++)->argp);
1384 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1385 preceded by a space. LEVELS is a pointer to a byte vector the length
1386 returned by argp_args_levels; it should be initialized to zero, and
1387 updated by this routine for the next call if ADVANCE is true. True is
1388 returned as long as there are more patterns to output. */
1390 argp_args_usage (const struct argp *argp, const struct argp_state *state,
1391 char **levels, int advance, argp_fmtstream_t stream)
1393 char *our_level = *levels;
1395 const struct argp_child *child = argp->children;
1396 const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
1397 const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
1401 const char *cp = fdoc;
1402 nl = __strchrnul (cp, '\n');
1404 /* This is a `multi-level' args doc; advance to the correct position
1405 as determined by our state in LEVELS, and update LEVELS. */
1409 for (i = 0; i < *our_level; i++)
1410 cp = nl + 1, nl = __strchrnul (cp, '\n');
1414 /* Manually do line wrapping so that it (probably) won't get wrapped at
1415 any embedded spaces. */
1416 space (stream, 1 + nl - cp);
1418 __argp_fmtstream_write (stream, cp, nl - cp);
1420 if (fdoc && fdoc != tdoc)
1421 free ((char *)fdoc); /* Free user's modified doc string. */
1425 advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
1427 if (advance && multiple)
1429 /* Need to increment our level. */
1431 /* There's more we can do here. */
1434 advance = 0; /* Our parent shouldn't advance also. */
1436 else if (*our_level > 0)
1437 /* We had multiple levels, but used them up; reset to zero. */
1444 /* Print the documentation for ARGP to STREAM; if POST is false, then
1445 everything preceeding a `\v' character in the documentation strings (or
1446 the whole string, for those with none) is printed, otherwise, everything
1447 following the `\v' character (nothing for strings without). Each separate
1448 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1449 then the first is as well. If FIRST_ONLY is true, only the first
1450 occurrence is output. Returns true if anything was output. */
1452 argp_doc (const struct argp *argp, const struct argp_state *state,
1453 int post, int pre_blank, int first_only,
1454 argp_fmtstream_t stream)
1457 const char *inp_text;
1460 size_t inp_text_limit = 0;
1461 const char *doc = dgettext (argp->argp_domain, argp->doc);
1462 const struct argp_child *child = argp->children;
1466 char *vt = strchr (doc, '\v');
1467 inp_text = post ? (vt ? vt + 1 : 0) : doc;
1468 inp_text_limit = (!post && vt) ? (vt - doc) : 0;
1473 if (argp->help_filter)
1474 /* We have to filter the doc strings. */
1477 /* Copy INP_TEXT so that it's nul-terminated. */
1478 inp_text = __strndup (inp_text, inp_text_limit);
1479 input = __argp_input (argp, state);
1481 (*argp->help_filter) (post
1482 ? ARGP_KEY_HELP_POST_DOC
1483 : ARGP_KEY_HELP_PRE_DOC,
1487 text = (const char *) inp_text;
1492 __argp_fmtstream_putc (stream, '\n');
1494 if (text == inp_text && inp_text_limit)
1495 __argp_fmtstream_write (stream, inp_text, inp_text_limit);
1497 __argp_fmtstream_puts (stream, text);
1499 if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
1500 __argp_fmtstream_putc (stream, '\n');
1505 if (text && text != inp_text)
1506 free ((char *) text); /* Free TEXT returned from the help filter. */
1507 if (inp_text && inp_text_limit && argp->help_filter)
1508 free ((char *) inp_text); /* We copied INP_TEXT, so free it now. */
1510 if (post && argp->help_filter)
1511 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1513 text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
1516 if (anything || pre_blank)
1517 __argp_fmtstream_putc (stream, '\n');
1518 __argp_fmtstream_puts (stream, text);
1519 free ((char *) text);
1520 if (__argp_fmtstream_point (stream)
1521 > __argp_fmtstream_lmargin (stream))
1522 __argp_fmtstream_putc (stream, '\n');
1528 while (child->argp && !(first_only && anything))
1530 argp_doc ((child++)->argp, state,
1531 post, anything || pre_blank, first_only,
1537 /* Output a usage message for ARGP to STREAM. If called from
1538 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1539 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1542 _help (const struct argp *argp, const struct argp_state *state, FILE *stream,
1543 unsigned flags, char *name)
1545 int anything = 0; /* Whether we've output anything. */
1546 struct hol *hol = 0;
1547 argp_fmtstream_t fs;
1552 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1553 __flockfile (stream);
1556 if (! uparams.valid)
1557 fill_in_uparams (state);
1559 fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
1562 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1563 __funlockfile (stream);
1568 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
1570 hol = argp_hol (argp, 0);
1572 /* If present, these options always come last. */
1573 hol_set_group (hol, "help", -1);
1574 hol_set_group (hol, "version", -1);
1579 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
1580 /* Print a short `Usage:' message. */
1582 int first_pattern = 1, more_patterns;
1583 size_t num_pattern_levels = argp_args_levels (argp);
1584 char *pattern_levels = alloca (num_pattern_levels);
1586 memset (pattern_levels, 0, num_pattern_levels);
1591 int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
1592 char *levels = pattern_levels;
1595 __argp_fmtstream_printf (fs, "%s %s",
1596 dgettext (argp->argp_domain, "Usage:"),
1599 __argp_fmtstream_printf (fs, "%s %s",
1600 dgettext (argp->argp_domain, " or: "),
1603 /* We set the lmargin as well as the wmargin, because hol_usage
1604 manually wraps options with newline to avoid annoying breaks. */
1605 old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
1607 if (flags & ARGP_HELP_SHORT_USAGE)
1608 /* Just show where the options go. */
1610 if (hol->num_entries > 0)
1611 __argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
1615 /* Actually print the options. */
1617 hol_usage (hol, fs);
1618 flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once. */
1621 more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
1623 __argp_fmtstream_set_wmargin (fs, old_wm);
1624 __argp_fmtstream_set_lmargin (fs, old_lm);
1626 __argp_fmtstream_putc (fs, '\n');
1631 while (more_patterns);
1634 if (flags & ARGP_HELP_PRE_DOC)
1635 anything |= argp_doc (argp, state, 0, 0, 1, fs);
1637 if (flags & ARGP_HELP_SEE)
1639 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
1640 Try `%s --help' or `%s --usage' for more information.\n"),
1645 if (flags & ARGP_HELP_LONG)
1646 /* Print a long, detailed help message. */
1648 /* Print info about all the options. */
1649 if (hol->num_entries > 0)
1652 __argp_fmtstream_putc (fs, '\n');
1653 hol_help (hol, state, fs);
1658 if (flags & ARGP_HELP_POST_DOC)
1659 /* Print any documentation strings at the end. */
1660 anything |= argp_doc (argp, state, 1, anything, 0, fs);
1662 if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
1665 __argp_fmtstream_putc (fs, '\n');
1666 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
1667 "Report bugs to %s.\n"),
1668 argp_program_bug_address);
1672 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1673 __funlockfile (stream);
1679 __argp_fmtstream_free (fs);
1682 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1683 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1684 void __argp_help (const struct argp *argp, FILE *stream,
1685 unsigned flags, char *name)
1687 _help (argp, 0, stream, flags, name);
1690 weak_alias (__argp_help, argp_help)
1694 char *__argp_basename (char *name)
1696 char *short_name = strrchr (name, '/');
1697 return short_name ? short_name + 1 : name;
1701 __argp_short_program_name (void)
1703 # if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
1704 return program_invocation_short_name;
1705 # elif HAVE_DECL_PROGRAM_INVOCATION_NAME
1706 return __argp_basename (program_invocation_name);
1708 /* FIXME: What now? Miles suggests that it is better to use NULL,
1709 but currently the value is passed on directly to fputs_unlocked,
1710 so that requires more changes. */
1712 # warning No reasonable value to return
1713 # endif /* __GNUC__ */
1719 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1720 from the set ARGP_HELP_*. */
1722 __argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
1724 if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
1726 if (state && (state->flags & ARGP_LONG_ONLY))
1727 flags |= ARGP_HELP_LONG_ONLY;
1729 _help (state ? state->root_argp : 0, state, stream, flags,
1730 state ? state->name : __argp_short_program_name ());
1732 if (!state || ! (state->flags & ARGP_NO_EXIT))
1734 if (flags & ARGP_HELP_EXIT_ERR)
1735 exit (argp_err_exit_status);
1736 if (flags & ARGP_HELP_EXIT_OK)
1742 weak_alias (__argp_state_help, argp_state_help)
1745 /* If appropriate, print the printf string FMT and following args, preceded
1746 by the program name and `:', to stderr, and followed by a `Try ... --help'
1747 message, then exit (1). */
1749 __argp_error (const struct argp_state *state, const char *fmt, ...)
1751 if (!state || !(state->flags & ARGP_NO_ERRS))
1753 FILE *stream = state ? state->err_stream : stderr;
1759 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1760 __flockfile (stream);
1766 if (_IO_fwide (stream, 0) > 0)
1770 __asprintf (&buf, fmt, ap);
1772 __fwprintf (stream, L"%s: %s\n",
1773 state ? state->name : __argp_short_program_name (),
1781 fputs_unlocked (state
1782 ? state->name : __argp_short_program_name (),
1784 putc_unlocked (':', stream);
1785 putc_unlocked (' ', stream);
1787 vfprintf (stream, fmt, ap);
1789 putc_unlocked ('\n', stream);
1792 __argp_state_help (state, stream, ARGP_HELP_STD_ERR);
1796 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1797 __funlockfile (stream);
1803 weak_alias (__argp_error, argp_error)
1806 /* Similar to the standard gnu error-reporting function error(), but will
1807 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1808 to STATE->err_stream. This is useful for argument parsing code that is
1809 shared between program startup (when exiting is desired) and runtime
1810 option parsing (when typically an error code is returned instead). The
1811 difference between this function and argp_error is that the latter is for
1812 *parsing errors*, and the former is for other problems that occur during
1813 parsing but don't reflect a (syntactic) problem with the input. */
1815 __argp_failure (const struct argp_state *state, int status, int errnum,
1816 const char *fmt, ...)
1818 if (!state || !(state->flags & ARGP_NO_ERRS))
1820 FILE *stream = state ? state->err_stream : stderr;
1824 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1825 __flockfile (stream);
1829 if (_IO_fwide (stream, 0) > 0)
1830 __fwprintf (stream, L"%s",
1831 state ? state->name : __argp_short_program_name ());
1834 fputs_unlocked (state
1835 ? state->name : __argp_short_program_name (),
1844 if (_IO_fwide (stream, 0) > 0)
1848 __asprintf (&buf, fmt, ap);
1850 __fwprintf (stream, L": %s", buf);
1857 putc_unlocked (':', stream);
1858 putc_unlocked (' ', stream);
1860 vfprintf (stream, fmt, ap);
1871 if (_IO_fwide (stream, 0) > 0)
1872 __fwprintf (stream, L": %s",
1873 __strerror_r (errnum, buf, sizeof (buf)));
1877 putc_unlocked (':', stream);
1878 putc_unlocked (' ', stream);
1879 #if defined _LIBC || defined HAVE_STRERROR_R
1880 fputs (__strerror_r (errnum, buf, sizeof (buf)), stream);
1882 fputs (strerror (errnum), stream);
1888 if (_IO_fwide (stream, 0) > 0)
1889 putwc_unlocked (L'\n', stream);
1892 putc_unlocked ('\n', stream);
1894 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1895 __funlockfile (stream);
1898 if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
1904 weak_alias (__argp_failure, argp_failure)