1 /* Hierarchial argument parsing help output
2 Copyright (C) 1995-2003, 2004, 2005 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Written by Miles Bader <miles@gnu.ai.mit.edu>.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License along
17 with this program; if not, write to the Free Software Foundation,
18 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
21 # define _GNU_SOURCE 1
44 # define dgettext(domain, msgid) \
45 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
51 #include "argp-fmtstream.h"
52 #include "argp-namefrob.h"
55 # define SIZE_MAX ((size_t) -1)
58 /* User-selectable (using an environment variable) formatting parameters.
60 These may be specified in an environment variable called `ARGP_HELP_FMT',
61 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
62 Where VALn must be a positive integer. The list of variables is in the
63 UPARAM_NAMES vector, below. */
65 /* Default parameters. */
66 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
67 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
68 #define SHORT_OPT_COL 2 /* column in which short options start */
69 #define LONG_OPT_COL 6 /* column in which long options start */
70 #define DOC_OPT_COL 2 /* column in which doc options start */
71 #define OPT_DOC_COL 29 /* column in which option text starts */
72 #define HEADER_COL 1 /* column in which group headers are printed */
73 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
74 #define RMARGIN 79 /* right margin used for wrapping */
76 /* User-selectable (using an environment variable) formatting parameters.
77 They must all be of type `int' for the parsing code to work. */
80 /* If true, arguments for an option are shown with both short and long
81 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
82 If false, then if an option has both, the argument is only shown with
83 the long one, e.g., `-x, --longx=ARG', and a message indicating that
84 this really means both is printed below the options. */
87 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
88 been suppressed, an explanatory message should be printed. */
91 /* Various output columns. */
100 int valid; /* True when the values in here are valid. */
103 /* This is a global variable, as user options are only ever read once. */
104 static struct uparams uparams = {
105 DUP_ARGS, DUP_ARGS_NOTE,
106 SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,
107 USAGE_INDENT, RMARGIN,
111 /* A particular uparam, and what the user name is. */
114 const char *name; /* User name. */
115 int is_bool; /* Whether it's `boolean'. */
116 size_t uparams_offs; /* Location of the (int) field in UPARAMS. */
119 /* The name-field mappings we know about. */
120 static const struct uparam_name uparam_names[] =
122 { "dup-args", 1, offsetof (struct uparams, dup_args) },
123 { "dup-args-note", 1, offsetof (struct uparams, dup_args_note) },
124 { "short-opt-col", 0, offsetof (struct uparams, short_opt_col) },
125 { "long-opt-col", 0, offsetof (struct uparams, long_opt_col) },
126 { "doc-opt-col", 0, offsetof (struct uparams, doc_opt_col) },
127 { "opt-doc-col", 0, offsetof (struct uparams, opt_doc_col) },
128 { "header-col", 0, offsetof (struct uparams, header_col) },
129 { "usage-indent", 0, offsetof (struct uparams, usage_indent) },
130 { "rmargin", 0, offsetof (struct uparams, rmargin) },
134 /* Read user options from the environment, and fill in UPARAMS appropiately. */
136 fill_in_uparams (const struct argp_state *state)
138 const char *var = getenv ("ARGP_HELP_FMT");
140 #define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
151 const struct uparam_name *un;
152 int unspec = 0, val = 0;
153 const char *arg = var;
155 while (isalnum (*arg) || *arg == '-' || *arg == '_')
161 if (*arg == '\0' || *arg == ',')
163 else if (*arg == '=')
171 if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')
180 else if (isdigit (*arg))
183 while (isdigit (*arg))
188 for (un = uparam_names; un->name; un++)
189 if (strlen (un->name) == var_len
190 && strncmp (var, un->name, var_len) == 0)
192 if (unspec && !un->is_bool)
193 __argp_failure (state, 0, 0,
194 dgettext (state->root_argp->argp_domain, "\
195 %.*s: ARGP_HELP_FMT parameter requires a value"),
198 *(int *)((char *)&uparams + un->uparams_offs) = val;
202 __argp_failure (state, 0, 0,
203 dgettext (state->root_argp->argp_domain, "\
204 %.*s: Unknown ARGP_HELP_FMT parameter"),
213 __argp_failure (state, 0, 0,
214 dgettext (state->root_argp->argp_domain,
215 "Garbage in ARGP_HELP_FMT: %s"), var);
221 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
222 whether OPT is displayed or used in sorting, not option shadowing. */
223 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
225 /* Returns true if OPT is an alias for an earlier option. */
226 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
228 /* Returns true if OPT is an documentation-only entry. */
229 #define odoc(opt) ((opt)->flags & OPTION_DOC)
231 /* Returns true if OPT should not be translated */
232 #define onotrans(opt) ((opt)->flags & OPTION_NO_TRANS)
234 /* Returns true if OPT is the end-of-list marker for a list of options. */
235 #define oend(opt) __option_is_end (opt)
237 /* Returns true if OPT has a short option. */
238 #define oshort(opt) __option_is_short (opt)
241 The help format for a particular option is like:
243 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
245 Where ARG will be omitted if there's no argument, for this option, or
246 will be surrounded by "[" and "]" appropiately if the argument is
247 optional. The documentation string is word-wrapped appropiately, and if
248 the list of options is long enough, it will be started on a separate line.
249 If there are no short options for a given option, the first long option is
250 indented slighly in a way that's supposed to make most long options appear
251 to be in a separate column.
253 For example, the following output (from ps):
255 -p PID, --pid=PID List the process PID
256 --pgrp=PGRP List processes in the process group PGRP
257 -P, -x, --no-parent Include processes without parents
258 -Q, --all-fields Don't elide unusable fields (normally if there's
259 some reason ps can't print a field for any
260 process, it's removed from the output entirely)
261 -r, --reverse, --gratuitously-long-reverse-option
262 Reverse the order of any sort
263 --session[=SID] Add the processes from the session SID (which
264 defaults to the sid of the current process)
266 Here are some more options:
267 -f ZOT, --foonly=ZOT Glork a foonly
268 -z, --zaza Snit a zar
270 -?, --help Give this help list
271 --usage Give a short usage message
272 -V, --version Print program version
274 The struct argp_option array for the above could look like:
277 {"pid", 'p', "PID", 0, "List the process PID"},
278 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
279 {"no-parent", 'P', 0, 0, "Include processes without parents"},
280 {0, 'x', 0, OPTION_ALIAS},
281 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
282 " if there's some reason ps can't"
283 " print a field for any process, it's"
284 " removed from the output entirely)" },
285 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
286 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
287 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
288 "Add the processes from the session"
289 " SID (which defaults to the sid of"
290 " the current process)" },
292 {0,0,0,0, "Here are some more options:"},
293 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
294 {"zaza", 'z', 0, 0, "Snit a zar"},
299 Note that the last three options are automatically supplied by argp_parse,
300 unless you tell it not to with ARGP_NO_HELP.
304 /* Returns true if CH occurs between BEG and END. */
306 find_char (char ch, char *beg, char *end)
316 struct hol_cluster; /* fwd decl */
321 const struct argp_option *opt;
322 /* Number of options (including aliases). */
325 /* A pointers into the HOL's short_options field, to the first short option
326 letter for this entry. The order of the characters following this point
327 corresponds to the order of options pointed to by OPT, and there are at
328 most NUM. A short option recorded in a option following OPT is only
329 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
330 probably been shadowed by some other entry). */
333 /* Entries are sorted by their group first, in the order:
334 1, 2, ..., n, 0, -m, ..., -2, -1
335 and then alphabetically within each group. The default is 0. */
338 /* The cluster of options this entry belongs to, or 0 if none. */
339 struct hol_cluster *cluster;
341 /* The argp from which this option came. */
342 const struct argp *argp;
345 /* A cluster of entries to reflect the argp tree structure. */
348 /* A descriptive header printed before options in this cluster. */
351 /* Used to order clusters within the same group with the same parent,
352 according to the order in which they occurred in the parent argp's child
356 /* How to sort this cluster with respect to options and other clusters at the
357 same depth (clusters always follow options in the same group). */
360 /* The cluster to which this cluster belongs, or 0 if it's at the base
362 struct hol_cluster *parent;
364 /* The argp from which this cluster is (eventually) derived. */
365 const struct argp *argp;
367 /* The distance this cluster is from the root. */
370 /* Clusters in a given hol are kept in a linked list, to make freeing them
372 struct hol_cluster *next;
375 /* A list of options for help. */
378 /* An array of hol_entry's. */
379 struct hol_entry *entries;
380 /* The number of entries in this hol. If this field is zero, the others
382 unsigned num_entries;
384 /* A string containing all short options in this HOL. Each entry contains
385 pointers into this string, so the order can't be messed with blindly. */
388 /* Clusters of entries in this hol. */
389 struct hol_cluster *clusters;
392 /* Create a struct hol from the options in ARGP. CLUSTER is the
393 hol_cluster in which these entries occur, or 0, if at the root. */
395 make_hol (const struct argp *argp, struct hol_cluster *cluster)
398 const struct argp_option *o;
399 const struct argp_option *opts = argp->options;
400 struct hol_entry *entry;
401 unsigned num_short_options = 0;
402 struct hol *hol = malloc (sizeof (struct hol));
406 hol->num_entries = 0;
413 /* The first option must not be an alias. */
414 assert (! oalias (opts));
416 /* Calculate the space needed. */
417 for (o = opts; ! oend (o); o++)
422 num_short_options++; /* This is an upper bound. */
425 hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);
426 hol->short_options = malloc (num_short_options + 1);
428 assert (hol->entries && hol->short_options);
429 if (SIZE_MAX <= UINT_MAX)
430 assert (hol->num_entries <= SIZE_MAX / sizeof (struct hol_entry));
432 /* Fill in the entries. */
433 so = hol->short_options;
434 for (o = opts, entry = hol->entries; ! oend (o); entry++)
438 entry->short_options = so;
439 entry->group = cur_group =
442 : ((!o->name && !o->key)
445 entry->cluster = cluster;
451 if (oshort (o) && ! find_char (o->key, hol->short_options, so))
452 /* O has a valid short option which hasn't already been used.*/
456 while (! oend (o) && oalias (o));
458 *so = '\0'; /* null terminated so we can find the length */
464 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
465 associated argp child list entry), INDEX, and PARENT, and return a pointer
466 to it. ARGP is the argp that this cluster results from. */
467 static struct hol_cluster *
468 hol_add_cluster (struct hol *hol, int group, const char *header, int index,
469 struct hol_cluster *parent, const struct argp *argp)
471 struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));
480 cl->depth = parent ? parent->depth + 1 : 0;
482 cl->next = hol->clusters;
488 /* Free HOL and any resources it uses. */
490 hol_free (struct hol *hol)
492 struct hol_cluster *cl = hol->clusters;
496 struct hol_cluster *next = cl->next;
501 if (hol->num_entries > 0)
504 free (hol->short_options);
511 hol_entry_short_iterate (const struct hol_entry *entry,
512 int (*func)(const struct argp_option *opt,
513 const struct argp_option *real,
514 const char *domain, void *cookie),
515 const char *domain, void *cookie)
519 const struct argp_option *opt, *real = entry->opt;
520 char *so = entry->short_options;
522 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
523 if (oshort (opt) && *so == opt->key)
528 val = (*func)(opt, real, domain, cookie);
536 __attribute__ ((always_inline))
537 hol_entry_long_iterate (const struct hol_entry *entry,
538 int (*func)(const struct argp_option *opt,
539 const struct argp_option *real,
540 const char *domain, void *cookie),
541 const char *domain, void *cookie)
545 const struct argp_option *opt, *real = entry->opt;
547 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
553 val = (*func)(opt, real, domain, cookie);
559 /* Iterator that returns true for the first short option. */
561 until_short (const struct argp_option *opt, const struct argp_option *real,
562 const char *domain, void *cookie)
564 return oshort (opt) ? opt->key : 0;
567 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
569 hol_entry_first_short (const struct hol_entry *entry)
571 return hol_entry_short_iterate (entry, until_short,
572 entry->argp->argp_domain, 0);
575 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
577 hol_entry_first_long (const struct hol_entry *entry)
579 const struct argp_option *opt;
581 for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
582 if (opt->name && ovisible (opt))
587 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
589 static struct hol_entry *
590 hol_find_entry (struct hol *hol, const char *name)
592 struct hol_entry *entry = hol->entries;
593 unsigned num_entries = hol->num_entries;
595 while (num_entries-- > 0)
597 const struct argp_option *opt = entry->opt;
598 unsigned num_opts = entry->num;
600 while (num_opts-- > 0)
601 if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
612 /* If an entry with the long option NAME occurs in HOL, set it's special
613 sort position to GROUP. */
615 hol_set_group (struct hol *hol, const char *name, int group)
617 struct hol_entry *entry = hol_find_entry (hol, name);
619 entry->group = group;
622 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
623 EQ is what to return if GROUP1 and GROUP2 are the same. */
625 group_cmp (int group1, int group2, int eq)
627 if (group1 == group2)
629 else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
630 return group1 - group2;
632 return group2 - group1;
635 /* Compare clusters CL1 & CL2 by the order that they should appear in
638 hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
640 /* If one cluster is deeper than the other, use its ancestor at the same
641 level, so that finding the common ancestor is straightforward. */
642 while (cl1->depth < cl2->depth)
644 while (cl2->depth < cl1->depth)
647 /* Now reduce both clusters to their ancestors at the point where both have
648 a common parent; these can be directly compared. */
649 while (cl1->parent != cl2->parent)
650 cl1 = cl1->parent, cl2 = cl2->parent;
652 return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
655 /* Return the ancestor of CL that's just below the root (i.e., has a parent
657 static struct hol_cluster *
658 hol_cluster_base (struct hol_cluster *cl)
665 /* Return true if CL1 is a child of CL2. */
667 hol_cluster_is_child (const struct hol_cluster *cl1,
668 const struct hol_cluster *cl2)
670 while (cl1 && cl1 != cl2)
675 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
676 that should be used for comparisons, and returns true iff it should be
677 treated as a non-option. */
679 canon_doc_option (const char **name)
687 /* Skip initial whitespace. */
688 while (isspace (**name))
690 /* Decide whether this looks like an option (leading `-') or not. */
691 non_opt = (**name != '-');
692 /* Skip until part of name used for sorting. */
693 while (**name && !isalnum (**name))
699 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
702 hol_entry_cmp (const struct hol_entry *entry1,
703 const struct hol_entry *entry2)
705 /* The group numbers by which the entries should be ordered; if either is
706 in a cluster, then this is just the group within the cluster. */
707 int group1 = entry1->group, group2 = entry2->group;
709 if (entry1->cluster != entry2->cluster)
711 /* The entries are not within the same cluster, so we can't compare them
712 directly, we have to use the appropiate clustering level too. */
713 if (! entry1->cluster)
714 /* ENTRY1 is at the `base level', not in a cluster, so we have to
715 compare it's group number with that of the base cluster in which
716 ENTRY2 resides. Note that if they're in the same group, the
717 clustered option always comes laster. */
718 return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
719 else if (! entry2->cluster)
720 /* Likewise, but ENTRY2's not in a cluster. */
721 return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
723 /* Both entries are in clusters, we can just compare the clusters. */
724 return hol_cluster_cmp (entry1->cluster, entry2->cluster);
726 else if (group1 == group2)
727 /* The entries are both in the same cluster and group, so compare them
730 int short1 = hol_entry_first_short (entry1);
731 int short2 = hol_entry_first_short (entry2);
732 int doc1 = odoc (entry1->opt);
733 int doc2 = odoc (entry2->opt);
734 const char *long1 = hol_entry_first_long (entry1);
735 const char *long2 = hol_entry_first_long (entry2);
738 doc1 = canon_doc_option (&long1);
740 doc2 = canon_doc_option (&long2);
743 /* `documentation' options always follow normal options (or
744 documentation options that *look* like normal options). */
746 else if (!short1 && !short2 && long1 && long2)
747 /* Only long options. */
748 return __strcasecmp (long1, long2);
750 /* Compare short/short, long/short, short/long, using the first
751 character of long options. Entries without *any* valid
752 options (such as options with OPTION_HIDDEN set) will be put
753 first, but as they're not displayed, it doesn't matter where
756 char first1 = short1 ? short1 : long1 ? *long1 : 0;
757 char first2 = short2 ? short2 : long2 ? *long2 : 0;
759 int lower_cmp = _tolower (first1) - _tolower (first2);
761 int lower_cmp = tolower (first1) - tolower (first2);
763 /* Compare ignoring case, except when the options are both the
764 same letter, in which case lower-case always comes first. */
765 return lower_cmp ? lower_cmp : first2 - first1;
769 /* Within the same cluster, but not the same group, so just compare
771 return group_cmp (group1, group2, 0);
774 /* Version of hol_entry_cmp with correct signature for qsort. */
776 hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
778 return hol_entry_cmp (entry1_v, entry2_v);
781 /* Sort HOL by group and alphabetically by option name (with short options
782 taking precedence over long). Since the sorting is for display purposes
783 only, the shadowing of options isn't effected. */
785 hol_sort (struct hol *hol)
787 if (hol->num_entries > 0)
788 qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
792 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
793 any in MORE with the same name. */
795 hol_append (struct hol *hol, struct hol *more)
797 struct hol_cluster **cl_end = &hol->clusters;
799 /* Steal MORE's cluster list, and add it to the end of HOL's. */
801 cl_end = &(*cl_end)->next;
802 *cl_end = more->clusters;
806 if (more->num_entries > 0)
808 if (hol->num_entries == 0)
810 hol->num_entries = more->num_entries;
811 hol->entries = more->entries;
812 hol->short_options = more->short_options;
813 more->num_entries = 0; /* Mark MORE's fields as invalid. */
816 /* Append the entries in MORE to those in HOL, taking care to only add
817 non-shadowed SHORT_OPTIONS values. */
822 unsigned num_entries = hol->num_entries + more->num_entries;
823 struct hol_entry *entries =
824 malloc (num_entries * sizeof (struct hol_entry));
825 unsigned hol_so_len = strlen (hol->short_options);
826 char *short_options =
827 malloc (hol_so_len + strlen (more->short_options) + 1);
829 assert (entries && short_options);
830 if (SIZE_MAX <= UINT_MAX)
831 assert (num_entries <= SIZE_MAX / sizeof (struct hol_entry));
833 __mempcpy (__mempcpy (entries, hol->entries,
834 hol->num_entries * sizeof (struct hol_entry)),
836 more->num_entries * sizeof (struct hol_entry));
838 __mempcpy (short_options, hol->short_options, hol_so_len);
840 /* Fix up the short options pointers from HOL. */
841 for (e = entries, left = hol->num_entries; left > 0; e++, left--)
842 e->short_options += (short_options - hol->short_options);
844 /* Now add the short options from MORE, fixing up its entries
846 so = short_options + hol_so_len;
847 more_so = more->short_options;
848 for (left = more->num_entries; left > 0; e++, left--)
851 const struct argp_option *opt;
853 e->short_options = so;
855 for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
858 if (oshort (opt) && ch == opt->key)
859 /* The next short option in MORE_SO, CH, is from OPT. */
861 if (! find_char (ch, short_options,
862 short_options + hol_so_len))
863 /* The short option CH isn't shadowed by HOL's options,
864 so add it to the sum. */
874 free (hol->short_options);
876 hol->entries = entries;
877 hol->num_entries = num_entries;
878 hol->short_options = short_options;
885 /* Inserts enough spaces to make sure STREAM is at column COL. */
887 indent_to (argp_fmtstream_t stream, unsigned col)
889 int needed = col - __argp_fmtstream_point (stream);
891 __argp_fmtstream_putc (stream, ' ');
894 /* Output to STREAM either a space, or a newline if there isn't room for at
895 least ENSURE characters before the right margin. */
897 space (argp_fmtstream_t stream, size_t ensure)
899 if (__argp_fmtstream_point (stream) + ensure
900 >= __argp_fmtstream_rmargin (stream))
901 __argp_fmtstream_putc (stream, '\n');
903 __argp_fmtstream_putc (stream, ' ');
906 /* If the option REAL has an argument, we print it in using the printf
907 format REQ_FMT or OPT_FMT depending on whether it's a required or
908 optional argument. */
910 arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
911 const char *domain, argp_fmtstream_t stream)
915 if (real->flags & OPTION_ARG_OPTIONAL)
916 __argp_fmtstream_printf (stream, opt_fmt,
917 dgettext (domain, real->arg));
919 __argp_fmtstream_printf (stream, req_fmt,
920 dgettext (domain, real->arg));
924 /* Helper functions for hol_entry_help. */
926 /* State used during the execution of hol_help. */
927 struct hol_help_state
929 /* PREV_ENTRY should contain the previous entry printed, or 0. */
930 struct hol_entry *prev_entry;
932 /* If an entry is in a different group from the previous one, and SEP_GROUPS
933 is true, then a blank line will be printed before any output. */
936 /* True if a duplicate option argument was suppressed (only ever set if
937 UPARAMS.dup_args is false). */
938 int suppressed_dup_arg;
941 /* Some state used while printing a help entry (used to communicate with
942 helper functions). See the doc for hol_entry_help for more info, as most
943 of the fields are copied from its arguments. */
946 const struct hol_entry *entry;
947 argp_fmtstream_t stream;
948 struct hol_help_state *hhstate;
950 /* True if nothing's been printed so far. */
953 /* If non-zero, the state that was used to print this help. */
954 const struct argp_state *state;
957 /* If a user doc filter should be applied to DOC, do so. */
959 filter_doc (const char *doc, int key, const struct argp *argp,
960 const struct argp_state *state)
962 if (argp->help_filter)
963 /* We must apply a user filter to this output. */
965 void *input = __argp_input (argp, state);
966 return (*argp->help_filter) (key, doc, input);
973 /* Prints STR as a header line, with the margin lines set appropiately, and
974 notes the fact that groups should be separated with a blank line. ARGP is
975 the argp that should dictate any user doc filtering to take place. Note
976 that the previous wrap margin isn't restored, but the left margin is reset
979 print_header (const char *str, const struct argp *argp,
980 struct pentry_state *pest)
982 const char *tstr = dgettext (argp->argp_domain, str);
983 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
989 if (pest->hhstate->prev_entry)
990 /* Precede with a blank line. */
991 __argp_fmtstream_putc (pest->stream, '\n');
992 indent_to (pest->stream, uparams.header_col);
993 __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
994 __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
995 __argp_fmtstream_puts (pest->stream, fstr);
996 __argp_fmtstream_set_lmargin (pest->stream, 0);
997 __argp_fmtstream_putc (pest->stream, '\n');
1000 pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
1004 free ((char *) fstr);
1007 /* Inserts a comma if this isn't the first item on the line, and then makes
1008 sure we're at least to column COL. If this *is* the first item on a line,
1009 prints any pending whitespace/headers that should precede this line. Also
1012 comma (unsigned col, struct pentry_state *pest)
1016 const struct hol_entry *pe = pest->hhstate->prev_entry;
1017 const struct hol_cluster *cl = pest->entry->cluster;
1019 if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
1020 __argp_fmtstream_putc (pest->stream, '\n');
1022 if (cl && cl->header && *cl->header
1024 || (pe->cluster != cl
1025 && !hol_cluster_is_child (pe->cluster, cl))))
1026 /* If we're changing clusters, then this must be the start of the
1027 ENTRY's cluster unless that is an ancestor of the previous one
1028 (in which case we had just popped into a sub-cluster for a bit).
1029 If so, then print the cluster's header line. */
1031 int old_wm = __argp_fmtstream_wmargin (pest->stream);
1032 print_header (cl->header, cl->argp, pest);
1033 __argp_fmtstream_set_wmargin (pest->stream, old_wm);
1039 __argp_fmtstream_puts (pest->stream, ", ");
1041 indent_to (pest->stream, col);
1044 /* Print help for ENTRY to STREAM. */
1046 hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
1047 argp_fmtstream_t stream, struct hol_help_state *hhstate)
1050 const struct argp_option *real = entry->opt, *opt;
1051 char *so = entry->short_options;
1052 int have_long_opt = 0; /* We have any long options. */
1053 /* Saved margins. */
1054 int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
1055 int old_wm = __argp_fmtstream_wmargin (stream);
1056 /* PEST is a state block holding some of our variables that we'd like to
1057 share with helper functions. */
1058 struct pentry_state pest;
1061 pest.stream = stream;
1062 pest.hhstate = hhstate;
1067 for (opt = real, num = entry->num; num > 0; opt++, num--)
1068 if (opt->name && ovisible (opt))
1074 /* First emit short options. */
1075 __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
1076 for (opt = real, num = entry->num; num > 0; opt++, num--)
1077 if (oshort (opt) && opt->key == *so)
1078 /* OPT has a valid (non shadowed) short option. */
1082 comma (uparams.short_opt_col, &pest);
1083 __argp_fmtstream_putc (stream, '-');
1084 __argp_fmtstream_putc (stream, *so);
1085 if (!have_long_opt || uparams.dup_args)
1086 arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
1088 hhstate->suppressed_dup_arg = 1;
1093 /* Now, long options. */
1095 /* A `documentation' option. */
1097 __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
1098 for (opt = real, num = entry->num; num > 0; opt++, num--)
1099 if (opt->name && *opt->name && ovisible (opt))
1101 comma (uparams.doc_opt_col, &pest);
1102 /* Calling dgettext here isn't quite right, since sorting will
1103 have been done on the original; but documentation options
1104 should be pretty rare anyway... */
1105 __argp_fmtstream_puts (stream,
1108 dgettext (state->root_argp->argp_domain,
1113 /* A real long option. */
1115 int first_long_opt = 1;
1117 __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
1118 for (opt = real, num = entry->num; num > 0; opt++, num--)
1119 if (opt->name && ovisible (opt))
1121 comma (uparams.long_opt_col, &pest);
1122 __argp_fmtstream_printf (stream, "--%s", opt->name);
1123 if (first_long_opt || uparams.dup_args)
1124 arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
1127 hhstate->suppressed_dup_arg = 1;
1131 /* Next, documentation strings. */
1132 __argp_fmtstream_set_lmargin (stream, 0);
1136 /* Didn't print any switches, what's up? */
1137 if (!oshort (real) && !real->name)
1138 /* This is a group header, print it nicely. */
1139 print_header (real->doc, entry->argp, &pest);
1141 /* Just a totally shadowed option or null header; print nothing. */
1142 goto cleanup; /* Just return, after cleaning up. */
1146 const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
1148 const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
1151 unsigned int col = __argp_fmtstream_point (stream);
1153 __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
1154 __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
1156 if (col > (unsigned int) (uparams.opt_doc_col + 3))
1157 __argp_fmtstream_putc (stream, '\n');
1158 else if (col >= (unsigned int) uparams.opt_doc_col)
1159 __argp_fmtstream_puts (stream, " ");
1161 indent_to (stream, uparams.opt_doc_col);
1163 __argp_fmtstream_puts (stream, fstr);
1165 if (fstr && fstr != tstr)
1166 free ((char *) fstr);
1168 /* Reset the left margin. */
1169 __argp_fmtstream_set_lmargin (stream, 0);
1170 __argp_fmtstream_putc (stream, '\n');
1173 hhstate->prev_entry = entry;
1176 __argp_fmtstream_set_lmargin (stream, old_lm);
1177 __argp_fmtstream_set_wmargin (stream, old_wm);
1180 /* Output a long help message about the options in HOL to STREAM. */
1182 hol_help (struct hol *hol, const struct argp_state *state,
1183 argp_fmtstream_t stream)
1186 struct hol_entry *entry;
1187 struct hol_help_state hhstate = { 0, 0, 0 };
1189 for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
1190 hol_entry_help (entry, state, stream, &hhstate);
1192 if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
1194 const char *tstr = dgettext (state->root_argp->argp_domain, "\
1195 Mandatory or optional arguments to long options are also mandatory or \
1196 optional for any corresponding short options.");
1197 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
1198 state ? state->root_argp : 0, state);
1201 __argp_fmtstream_putc (stream, '\n');
1202 __argp_fmtstream_puts (stream, fstr);
1203 __argp_fmtstream_putc (stream, '\n');
1205 if (fstr && fstr != tstr)
1206 free ((char *) fstr);
1210 /* Helper functions for hol_usage. */
1212 /* If OPT is a short option without an arg, append its key to the string
1213 pointer pointer to by COOKIE, and advance the pointer. */
1215 add_argless_short_opt (const struct argp_option *opt,
1216 const struct argp_option *real,
1217 const char *domain, void *cookie)
1219 char **snao_end = cookie;
1220 if (!(opt->arg || real->arg)
1221 && !((opt->flags | real->flags) & OPTION_NO_USAGE))
1222 *(*snao_end)++ = opt->key;
1226 /* If OPT is a short option with an arg, output a usage entry for it to the
1227 stream pointed at by COOKIE. */
1229 usage_argful_short_opt (const struct argp_option *opt,
1230 const struct argp_option *real,
1231 const char *domain, void *cookie)
1233 argp_fmtstream_t stream = cookie;
1234 const char *arg = opt->arg;
1235 int flags = opt->flags | real->flags;
1240 if (arg && !(flags & OPTION_NO_USAGE))
1242 arg = dgettext (domain, arg);
1244 if (flags & OPTION_ARG_OPTIONAL)
1245 __argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
1248 /* Manually do line wrapping so that it (probably) won't
1249 get wrapped at the embedded space. */
1250 space (stream, 6 + strlen (arg));
1251 __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
1258 /* Output a usage entry for the long option opt to the stream pointed at by
1261 usage_long_opt (const struct argp_option *opt,
1262 const struct argp_option *real,
1263 const char *domain, void *cookie)
1265 argp_fmtstream_t stream = cookie;
1266 const char *arg = opt->arg;
1267 int flags = opt->flags | real->flags;
1272 if (! (flags & OPTION_NO_USAGE))
1276 arg = dgettext (domain, arg);
1277 if (flags & OPTION_ARG_OPTIONAL)
1278 __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
1280 __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
1283 __argp_fmtstream_printf (stream, " [--%s]", opt->name);
1289 /* Print a short usage description for the arguments in HOL to STREAM. */
1291 hol_usage (struct hol *hol, argp_fmtstream_t stream)
1293 if (hol->num_entries > 0)
1296 struct hol_entry *entry;
1297 char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
1298 char *snao_end = short_no_arg_opts;
1300 /* First we put a list of short options without arguments. */
1301 for (entry = hol->entries, nentries = hol->num_entries
1303 ; entry++, nentries--)
1304 hol_entry_short_iterate (entry, add_argless_short_opt,
1305 entry->argp->argp_domain, &snao_end);
1306 if (snao_end > short_no_arg_opts)
1309 __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
1312 /* Now a list of short options *with* arguments. */
1313 for (entry = hol->entries, nentries = hol->num_entries
1315 ; entry++, nentries--)
1316 hol_entry_short_iterate (entry, usage_argful_short_opt,
1317 entry->argp->argp_domain, stream);
1319 /* Finally, a list of long options (whew!). */
1320 for (entry = hol->entries, nentries = hol->num_entries
1322 ; entry++, nentries--)
1323 hol_entry_long_iterate (entry, usage_long_opt,
1324 entry->argp->argp_domain, stream);
1328 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1329 cluster in which ARGP's entries should be clustered, or 0. */
1331 argp_hol (const struct argp *argp, struct hol_cluster *cluster)
1333 const struct argp_child *child = argp->children;
1334 struct hol *hol = make_hol (argp, cluster);
1338 struct hol_cluster *child_cluster =
1339 ((child->group || child->header)
1340 /* Put CHILD->argp within its own cluster. */
1341 ? hol_add_cluster (hol, child->group, child->header,
1342 child - argp->children, cluster, argp)
1343 /* Just merge it into the parent's cluster. */
1345 hol_append (hol, argp_hol (child->argp, child_cluster)) ;
1351 /* Calculate how many different levels with alternative args strings exist in
1354 argp_args_levels (const struct argp *argp)
1357 const struct argp_child *child = argp->children;
1359 if (argp->args_doc && strchr (argp->args_doc, '\n'))
1364 levels += argp_args_levels ((child++)->argp);
1369 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1370 preceded by a space. LEVELS is a pointer to a byte vector the length
1371 returned by argp_args_levels; it should be initialized to zero, and
1372 updated by this routine for the next call if ADVANCE is true. True is
1373 returned as long as there are more patterns to output. */
1375 argp_args_usage (const struct argp *argp, const struct argp_state *state,
1376 char **levels, int advance, argp_fmtstream_t stream)
1378 char *our_level = *levels;
1380 const struct argp_child *child = argp->children;
1381 const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
1382 const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
1386 const char *cp = fdoc;
1387 nl = __strchrnul (cp, '\n');
1389 /* This is a `multi-level' args doc; advance to the correct position
1390 as determined by our state in LEVELS, and update LEVELS. */
1394 for (i = 0; i < *our_level; i++)
1395 cp = nl + 1, nl = __strchrnul (cp, '\n');
1399 /* Manually do line wrapping so that it (probably) won't get wrapped at
1400 any embedded spaces. */
1401 space (stream, 1 + nl - cp);
1403 __argp_fmtstream_write (stream, cp, nl - cp);
1405 if (fdoc && fdoc != tdoc)
1406 free ((char *)fdoc); /* Free user's modified doc string. */
1410 advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
1412 if (advance && multiple)
1414 /* Need to increment our level. */
1416 /* There's more we can do here. */
1419 advance = 0; /* Our parent shouldn't advance also. */
1421 else if (*our_level > 0)
1422 /* We had multiple levels, but used them up; reset to zero. */
1429 /* Print the documentation for ARGP to STREAM; if POST is false, then
1430 everything preceeding a `\v' character in the documentation strings (or
1431 the whole string, for those with none) is printed, otherwise, everything
1432 following the `\v' character (nothing for strings without). Each separate
1433 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1434 then the first is as well. If FIRST_ONLY is true, only the first
1435 occurrence is output. Returns true if anything was output. */
1437 argp_doc (const struct argp *argp, const struct argp_state *state,
1438 int post, int pre_blank, int first_only,
1439 argp_fmtstream_t stream)
1442 const char *inp_text;
1445 size_t inp_text_limit = 0;
1446 const char *doc = dgettext (argp->argp_domain, argp->doc);
1447 const struct argp_child *child = argp->children;
1451 char *vt = strchr (doc, '\v');
1452 inp_text = post ? (vt ? vt + 1 : 0) : doc;
1453 inp_text_limit = (!post && vt) ? (vt - doc) : 0;
1458 if (argp->help_filter)
1459 /* We have to filter the doc strings. */
1462 /* Copy INP_TEXT so that it's nul-terminated. */
1463 inp_text = __strndup (inp_text, inp_text_limit);
1464 input = __argp_input (argp, state);
1466 (*argp->help_filter) (post
1467 ? ARGP_KEY_HELP_POST_DOC
1468 : ARGP_KEY_HELP_PRE_DOC,
1472 text = (const char *) inp_text;
1477 __argp_fmtstream_putc (stream, '\n');
1479 if (text == inp_text && inp_text_limit)
1480 __argp_fmtstream_write (stream, inp_text, inp_text_limit);
1482 __argp_fmtstream_puts (stream, text);
1484 if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
1485 __argp_fmtstream_putc (stream, '\n');
1490 if (text && text != inp_text)
1491 free ((char *) text); /* Free TEXT returned from the help filter. */
1492 if (inp_text && inp_text_limit && argp->help_filter)
1493 free ((char *) inp_text); /* We copied INP_TEXT, so free it now. */
1495 if (post && argp->help_filter)
1496 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1498 text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
1501 if (anything || pre_blank)
1502 __argp_fmtstream_putc (stream, '\n');
1503 __argp_fmtstream_puts (stream, text);
1504 free ((char *) text);
1505 if (__argp_fmtstream_point (stream)
1506 > __argp_fmtstream_lmargin (stream))
1507 __argp_fmtstream_putc (stream, '\n');
1513 while (child->argp && !(first_only && anything))
1515 argp_doc ((child++)->argp, state,
1516 post, anything || pre_blank, first_only,
1522 /* Output a usage message for ARGP to STREAM. If called from
1523 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1524 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1527 _help (const struct argp *argp, const struct argp_state *state, FILE *stream,
1528 unsigned flags, char *name)
1530 int anything = 0; /* Whether we've output anything. */
1531 struct hol *hol = 0;
1532 argp_fmtstream_t fs;
1537 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1538 __flockfile (stream);
1541 if (! uparams.valid)
1542 fill_in_uparams (state);
1544 fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
1547 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1548 __funlockfile (stream);
1553 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
1555 hol = argp_hol (argp, 0);
1557 /* If present, these options always come last. */
1558 hol_set_group (hol, "help", -1);
1559 hol_set_group (hol, "version", -1);
1564 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
1565 /* Print a short `Usage:' message. */
1567 int first_pattern = 1, more_patterns;
1568 size_t num_pattern_levels = argp_args_levels (argp);
1569 char *pattern_levels = alloca (num_pattern_levels);
1571 memset (pattern_levels, 0, num_pattern_levels);
1576 int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
1577 char *levels = pattern_levels;
1580 __argp_fmtstream_printf (fs, "%s %s",
1581 dgettext (argp->argp_domain, "Usage:"),
1584 __argp_fmtstream_printf (fs, "%s %s",
1585 dgettext (argp->argp_domain, " or: "),
1588 /* We set the lmargin as well as the wmargin, because hol_usage
1589 manually wraps options with newline to avoid annoying breaks. */
1590 old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
1592 if (flags & ARGP_HELP_SHORT_USAGE)
1593 /* Just show where the options go. */
1595 if (hol->num_entries > 0)
1596 __argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
1600 /* Actually print the options. */
1602 hol_usage (hol, fs);
1603 flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once. */
1606 more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
1608 __argp_fmtstream_set_wmargin (fs, old_wm);
1609 __argp_fmtstream_set_lmargin (fs, old_lm);
1611 __argp_fmtstream_putc (fs, '\n');
1616 while (more_patterns);
1619 if (flags & ARGP_HELP_PRE_DOC)
1620 anything |= argp_doc (argp, state, 0, 0, 1, fs);
1622 if (flags & ARGP_HELP_SEE)
1624 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
1625 Try `%s --help' or `%s --usage' for more information.\n"),
1630 if (flags & ARGP_HELP_LONG)
1631 /* Print a long, detailed help message. */
1633 /* Print info about all the options. */
1634 if (hol->num_entries > 0)
1637 __argp_fmtstream_putc (fs, '\n');
1638 hol_help (hol, state, fs);
1643 if (flags & ARGP_HELP_POST_DOC)
1644 /* Print any documentation strings at the end. */
1645 anything |= argp_doc (argp, state, 1, anything, 0, fs);
1647 if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
1650 __argp_fmtstream_putc (fs, '\n');
1651 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
1652 "Report bugs to %s.\n"),
1653 argp_program_bug_address);
1657 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1658 __funlockfile (stream);
1664 __argp_fmtstream_free (fs);
1667 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1668 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1669 void __argp_help (const struct argp *argp, FILE *stream,
1670 unsigned flags, char *name)
1672 struct argp_state state;
1673 memset (&state, 0, sizeof state);
1674 state.root_argp = argp;
1675 _help (argp, &state, stream, flags, name);
1678 weak_alias (__argp_help, argp_help)
1681 #if ! (defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME)
1683 __argp_short_program_name (void)
1685 # if HAVE_DECL_PROGRAM_INVOCATION_NAME
1686 char *name = strrchr (program_invocation_name, '/');
1687 return name ? name + 1 : program_invocation_name;
1689 /* FIXME: What now? Miles suggests that it is better to use NULL,
1690 but currently the value is passed on directly to fputs_unlocked,
1691 so that requires more changes. */
1693 # warning No reasonable value to return
1694 # endif /* __GNUC__ */
1700 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1701 from the set ARGP_HELP_*. */
1703 __argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
1705 if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
1707 if (state && (state->flags & ARGP_LONG_ONLY))
1708 flags |= ARGP_HELP_LONG_ONLY;
1710 _help (state ? state->root_argp : 0, state, stream, flags,
1711 state ? state->name : __argp_short_program_name ());
1713 if (!state || ! (state->flags & ARGP_NO_EXIT))
1715 if (flags & ARGP_HELP_EXIT_ERR)
1716 exit (argp_err_exit_status);
1717 if (flags & ARGP_HELP_EXIT_OK)
1723 weak_alias (__argp_state_help, argp_state_help)
1726 /* If appropriate, print the printf string FMT and following args, preceded
1727 by the program name and `:', to stderr, and followed by a `Try ... --help'
1728 message, then exit (1). */
1730 __argp_error (const struct argp_state *state, const char *fmt, ...)
1732 if (!state || !(state->flags & ARGP_NO_ERRS))
1734 FILE *stream = state ? state->err_stream : stderr;
1740 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1741 __flockfile (stream);
1747 if (_IO_fwide (stream, 0) > 0)
1751 if (__asprintf (&buf, fmt, ap) < 0)
1754 __fwprintf (stream, L"%s: %s\n",
1755 state ? state->name : __argp_short_program_name (),
1763 fputs_unlocked (state
1764 ? state->name : __argp_short_program_name (),
1766 putc_unlocked (':', stream);
1767 putc_unlocked (' ', stream);
1769 vfprintf (stream, fmt, ap);
1771 putc_unlocked ('\n', stream);
1774 __argp_state_help (state, stream, ARGP_HELP_STD_ERR);
1778 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1779 __funlockfile (stream);
1785 weak_alias (__argp_error, argp_error)
1788 /* Similar to the standard gnu error-reporting function error(), but will
1789 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1790 to STATE->err_stream. This is useful for argument parsing code that is
1791 shared between program startup (when exiting is desired) and runtime
1792 option parsing (when typically an error code is returned instead). The
1793 difference between this function and argp_error is that the latter is for
1794 *parsing errors*, and the former is for other problems that occur during
1795 parsing but don't reflect a (syntactic) problem with the input. */
1797 __argp_failure (const struct argp_state *state, int status, int errnum,
1798 const char *fmt, ...)
1800 if (!state || !(state->flags & ARGP_NO_ERRS))
1802 FILE *stream = state ? state->err_stream : stderr;
1806 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1807 __flockfile (stream);
1811 if (_IO_fwide (stream, 0) > 0)
1812 __fwprintf (stream, L"%s",
1813 state ? state->name : __argp_short_program_name ());
1816 fputs_unlocked (state
1817 ? state->name : __argp_short_program_name (),
1826 if (_IO_fwide (stream, 0) > 0)
1830 if (__asprintf (&buf, fmt, ap) < 0)
1833 __fwprintf (stream, L": %s", buf);
1840 putc_unlocked (':', stream);
1841 putc_unlocked (' ', stream);
1843 vfprintf (stream, fmt, ap);
1854 if (_IO_fwide (stream, 0) > 0)
1855 __fwprintf (stream, L": %s",
1856 __strerror_r (errnum, buf, sizeof (buf)));
1860 char const *s = NULL;
1861 putc_unlocked (':', stream);
1862 putc_unlocked (' ', stream);
1863 #if _LIBC || (HAVE_DECL_STRERROR_R && STRERROR_R_CHAR_P)
1864 s = __strerror_r (errnum, buf, sizeof buf);
1865 #elif HAVE_DECL_STRERROR_R
1866 if (__strerror_r (errnum, buf, sizeof buf) == 0)
1870 if (! s && ! (s = strerror (errnum)))
1871 s = dgettext (state->root_argp->argp_domain,
1872 "Unknown system error");
1879 if (_IO_fwide (stream, 0) > 0)
1880 putwc_unlocked (L'\n', stream);
1883 putc_unlocked ('\n', stream);
1885 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1886 __funlockfile (stream);
1889 if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
1895 weak_alias (__argp_failure, argp_failure)