1 /* -*- buffer-read-only: t -*- vi: set ro: */
2 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */
3 /* Hierarchical argument parsing help output
4 Copyright (C) 1995-2005, 2007, 2009-2014 Free Software Foundation, Inc.
5 This file is part of the GNU C Library.
6 Written by Miles Bader <miles@gnu.ai.mit.edu>.
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 # define _GNU_SOURCE 1
46 # define dgettext(domain, msgid) \
47 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
53 #include "argp-fmtstream.h"
54 #include "argp-namefrob.h"
57 # define SIZE_MAX ((size_t) -1)
60 /* User-selectable (using an environment variable) formatting parameters.
62 These may be specified in an environment variable called 'ARGP_HELP_FMT',
63 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
64 Where VALn must be a positive integer. The list of variables is in the
65 UPARAM_NAMES vector, below. */
67 /* Default parameters. */
68 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
69 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
70 #define SHORT_OPT_COL 2 /* column in which short options start */
71 #define LONG_OPT_COL 6 /* column in which long options start */
72 #define DOC_OPT_COL 2 /* column in which doc options start */
73 #define OPT_DOC_COL 29 /* column in which option text starts */
74 #define HEADER_COL 1 /* column in which group headers are printed */
75 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
76 #define RMARGIN 79 /* right margin used for wrapping */
78 /* User-selectable (using an environment variable) formatting parameters.
79 They must all be of type 'int' for the parsing code to work. */
82 /* If true, arguments for an option are shown with both short and long
83 options, even when a given option has both, e.g. '-x ARG, --longx=ARG'.
84 If false, then if an option has both, the argument is only shown with
85 the long one, e.g., '-x, --longx=ARG', and a message indicating that
86 this really means both is printed below the options. */
89 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
90 been suppressed, an explanatory message should be printed. */
93 /* Various output columns. */
94 int short_opt_col; /* column in which short options start */
95 int long_opt_col; /* column in which long options start */
96 int doc_opt_col; /* column in which doc options start */
97 int opt_doc_col; /* column in which option text starts */
98 int header_col; /* column in which group headers are printed */
99 int usage_indent; /* indentation of wrapped usage lines */
100 int rmargin; /* right margin used for wrapping */
102 int valid; /* True when the values in here are valid. */
105 /* This is a global variable, as user options are only ever read once. */
106 static struct uparams uparams = {
107 DUP_ARGS, DUP_ARGS_NOTE,
108 SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,
109 USAGE_INDENT, RMARGIN,
113 /* A particular uparam, and what the user name is. */
116 const char *name; /* User name. */
117 int is_bool; /* Whether it's 'boolean'. */
118 size_t uparams_offs; /* Location of the (int) field in UPARAMS. */
121 /* The name-field mappings we know about. */
122 static const struct uparam_name uparam_names[] =
124 { "dup-args", 1, offsetof (struct uparams, dup_args) },
125 { "dup-args-note", 1, offsetof (struct uparams, dup_args_note) },
126 { "short-opt-col", 0, offsetof (struct uparams, short_opt_col) },
127 { "long-opt-col", 0, offsetof (struct uparams, long_opt_col) },
128 { "doc-opt-col", 0, offsetof (struct uparams, doc_opt_col) },
129 { "opt-doc-col", 0, offsetof (struct uparams, opt_doc_col) },
130 { "header-col", 0, offsetof (struct uparams, header_col) },
131 { "usage-indent", 0, offsetof (struct uparams, usage_indent) },
132 { "rmargin", 0, offsetof (struct uparams, rmargin) },
137 validate_uparams (const struct argp_state *state, struct uparams *upptr)
139 const struct uparam_name *up;
141 for (up = uparam_names; up->name; up++)
144 || up->uparams_offs == offsetof (struct uparams, rmargin))
146 if (*(int *)((char *)upptr + up->uparams_offs) >= upptr->rmargin)
148 __argp_failure (state, 0, 0,
149 dgettext (state->root_argp->argp_domain,
151 ARGP_HELP_FMT: %s value is less than or equal to %s"),
152 "rmargin", up->name);
160 /* Read user options from the environment, and fill in UPARAMS appropriately. */
162 fill_in_uparams (const struct argp_state *state)
164 const char *var = getenv ("ARGP_HELP_FMT");
165 struct uparams new_params = uparams;
167 #define SKIPWS(p) do { while (isspace ((unsigned char) *p)) p++; } while (0);
176 if (isalpha ((unsigned char) *var))
179 const struct uparam_name *un;
180 int unspec = 0, val = 0;
181 const char *arg = var;
183 while (isalnum ((unsigned char) *arg) || *arg == '-' || *arg == '_')
189 if (*arg == '\0' || *arg == ',')
191 else if (*arg == '=')
199 if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')
208 else if (isdigit ((unsigned char) *arg))
211 while (isdigit ((unsigned char) *arg))
216 for (un = uparam_names; un->name; un++)
217 if (strlen (un->name) == var_len
218 && strncmp (var, un->name, var_len) == 0)
220 if (unspec && !un->is_bool)
221 __argp_failure (state, 0, 0,
222 dgettext (state->root_argp->argp_domain,
224 %.*s: ARGP_HELP_FMT parameter requires a value"),
227 __argp_failure (state, 0, 0,
228 dgettext (state->root_argp->argp_domain,
230 %.*s: ARGP_HELP_FMT parameter must be positive"),
233 *(int *)((char *)&new_params + un->uparams_offs) = val;
237 __argp_failure (state, 0, 0,
238 dgettext (state->root_argp->argp_domain, "\
239 %.*s: Unknown ARGP_HELP_FMT parameter"),
248 __argp_failure (state, 0, 0,
249 dgettext (state->root_argp->argp_domain,
250 "Garbage in ARGP_HELP_FMT: %s"), var);
254 validate_uparams (state, &new_params);
258 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
259 whether OPT is displayed or used in sorting, not option shadowing. */
260 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
262 /* Returns true if OPT is an alias for an earlier option. */
263 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
265 /* Returns true if OPT is a documentation-only entry. */
266 #define odoc(opt) ((opt)->flags & OPTION_DOC)
268 /* Returns true if OPT should not be translated */
269 #define onotrans(opt) ((opt)->flags & OPTION_NO_TRANS)
271 /* Returns true if OPT is the end-of-list marker for a list of options. */
272 #define oend(opt) __option_is_end (opt)
274 /* Returns true if OPT has a short option. */
275 #define oshort(opt) __option_is_short (opt)
278 The help format for a particular option is like:
280 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
282 Where ARG will be omitted if there's no argument, for this option, or
283 will be surrounded by "[" and "]" appropriately if the argument is
284 optional. The documentation string is word-wrapped appropriately, and if
285 the list of options is long enough, it will be started on a separate line.
286 If there are no short options for a given option, the first long option is
287 indented slightly in a way that's supposed to make most long options appear
288 to be in a separate column.
290 For example, the following output (from ps):
292 -p PID, --pid=PID List the process PID
293 --pgrp=PGRP List processes in the process group PGRP
294 -P, -x, --no-parent Include processes without parents
295 -Q, --all-fields Don't elide unusable fields (normally if there's
296 some reason ps can't print a field for any
297 process, it's removed from the output entirely)
298 -r, --reverse, --gratuitously-long-reverse-option
299 Reverse the order of any sort
300 --session[=SID] Add the processes from the session SID (which
301 defaults to the sid of the current process)
303 Here are some more options:
304 -f ZOT, --foonly=ZOT Glork a foonly
305 -z, --zaza Snit a zar
307 -?, --help Give this help list
308 --usage Give a short usage message
309 -V, --version Print program version
311 The struct argp_option array for the above could look like:
314 {"pid", 'p', "PID", 0, "List the process PID"},
315 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
316 {"no-parent", 'P', 0, 0, "Include processes without parents"},
317 {0, 'x', 0, OPTION_ALIAS},
318 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
319 " if there's some reason ps can't"
320 " print a field for any process, it's"
321 " removed from the output entirely)" },
322 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
323 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
324 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
325 "Add the processes from the session"
326 " SID (which defaults to the sid of"
327 " the current process)" },
329 {0,0,0,0, "Here are some more options:"},
330 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
331 {"zaza", 'z', 0, 0, "Snit a zar"},
336 Note that the last three options are automatically supplied by argp_parse,
337 unless you tell it not to with ARGP_NO_HELP.
341 /* Returns true if CH occurs between BEG and END. */
343 find_char (char ch, char *beg, char *end)
353 struct hol_cluster; /* fwd decl */
358 const struct argp_option *opt;
359 /* Number of options (including aliases). */
362 /* A pointers into the HOL's short_options field, to the first short option
363 letter for this entry. The order of the characters following this point
364 corresponds to the order of options pointed to by OPT, and there are at
365 most NUM. A short option recorded in an option following OPT is only
366 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
367 probably been shadowed by some other entry). */
370 /* Entries are sorted by their group first, in the order:
371 1, 2, ..., n, 0, -m, ..., -2, -1
372 and then alphabetically within each group. The default is 0. */
375 /* The cluster of options this entry belongs to, or 0 if none. */
376 struct hol_cluster *cluster;
378 /* The argp from which this option came. */
379 const struct argp *argp;
381 /* Position in the array */
385 /* A cluster of entries to reflect the argp tree structure. */
388 /* A descriptive header printed before options in this cluster. */
391 /* Used to order clusters within the same group with the same parent,
392 according to the order in which they occurred in the parent argp's child
396 /* How to sort this cluster with respect to options and other clusters at the
397 same depth (clusters always follow options in the same group). */
400 /* The cluster to which this cluster belongs, or 0 if it's at the base
402 struct hol_cluster *parent;
404 /* The argp from which this cluster is (eventually) derived. */
405 const struct argp *argp;
407 /* The distance this cluster is from the root. */
410 /* Clusters in a given hol are kept in a linked list, to make freeing them
412 struct hol_cluster *next;
415 /* A list of options for help. */
418 /* An array of hol_entry's. */
419 struct hol_entry *entries;
420 /* The number of entries in this hol. If this field is zero, the others
422 unsigned num_entries;
424 /* A string containing all short options in this HOL. Each entry contains
425 pointers into this string, so the order can't be messed with blindly. */
428 /* Clusters of entries in this hol. */
429 struct hol_cluster *clusters;
432 /* Create a struct hol from the options in ARGP. CLUSTER is the
433 hol_cluster in which these entries occur, or 0, if at the root. */
435 make_hol (const struct argp *argp, struct hol_cluster *cluster)
438 const struct argp_option *o;
439 const struct argp_option *opts = argp->options;
440 struct hol_entry *entry;
441 unsigned num_short_options = 0;
442 struct hol *hol = malloc (sizeof (struct hol));
446 hol->num_entries = 0;
453 /* The first option must not be an alias. */
454 assert (! oalias (opts));
456 /* Calculate the space needed. */
457 for (o = opts; ! oend (o); o++)
462 num_short_options++; /* This is an upper bound. */
465 hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);
466 hol->short_options = malloc (num_short_options + 1);
468 assert (hol->entries && hol->short_options);
469 if (SIZE_MAX <= UINT_MAX)
470 assert (hol->num_entries <= SIZE_MAX / sizeof (struct hol_entry));
472 /* Fill in the entries. */
473 so = hol->short_options;
474 for (o = opts, entry = hol->entries; ! oend (o); entry++)
478 entry->short_options = so;
479 entry->group = cur_group =
482 : ((!o->name && !o->key)
485 entry->cluster = cluster;
491 if (oshort (o) && ! find_char (o->key, hol->short_options, so))
492 /* O has a valid short option which hasn't already been used.*/
496 while (! oend (o) && oalias (o));
498 *so = '\0'; /* null terminated so we can find the length */
504 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
505 associated argp child list entry), INDEX, and PARENT, and return a pointer
506 to it. ARGP is the argp that this cluster results from. */
507 static struct hol_cluster *
508 hol_add_cluster (struct hol *hol, int group, const char *header, int index,
509 struct hol_cluster *parent, const struct argp *argp)
511 struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));
520 cl->depth = parent ? parent->depth + 1 : 0;
522 cl->next = hol->clusters;
528 /* Free HOL and any resources it uses. */
530 hol_free (struct hol *hol)
532 struct hol_cluster *cl = hol->clusters;
536 struct hol_cluster *next = cl->next;
541 if (hol->num_entries > 0)
544 free (hol->short_options);
551 hol_entry_short_iterate (const struct hol_entry *entry,
552 int (*func)(const struct argp_option *opt,
553 const struct argp_option *real,
554 const char *domain, void *cookie),
555 const char *domain, void *cookie)
559 const struct argp_option *opt, *real = entry->opt;
560 char *so = entry->short_options;
562 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
563 if (oshort (opt) && *so == opt->key)
568 val = (*func)(opt, real, domain, cookie);
577 __attribute__ ((always_inline))
579 hol_entry_long_iterate (const struct hol_entry *entry,
580 int (*func)(const struct argp_option *opt,
581 const struct argp_option *real,
582 const char *domain, void *cookie),
583 const char *domain, void *cookie)
587 const struct argp_option *opt, *real = entry->opt;
589 for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
595 val = (*func)(opt, real, domain, cookie);
601 /* Iterator that returns true for the first short option. */
603 until_short (const struct argp_option *opt, const struct argp_option *real,
604 const char *domain, void *cookie)
606 return oshort (opt) ? opt->key : 0;
609 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
611 hol_entry_first_short (const struct hol_entry *entry)
613 return hol_entry_short_iterate (entry, until_short,
614 entry->argp->argp_domain, 0);
617 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
619 hol_entry_first_long (const struct hol_entry *entry)
621 const struct argp_option *opt;
623 for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
624 if (opt->name && ovisible (opt))
629 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
631 static struct hol_entry *
632 hol_find_entry (struct hol *hol, const char *name)
634 struct hol_entry *entry = hol->entries;
635 unsigned num_entries = hol->num_entries;
637 while (num_entries-- > 0)
639 const struct argp_option *opt = entry->opt;
640 unsigned num_opts = entry->num;
642 while (num_opts-- > 0)
643 if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
654 /* If an entry with the long option NAME occurs in HOL, set its special
655 sort position to GROUP. */
657 hol_set_group (struct hol *hol, const char *name, int group)
659 struct hol_entry *entry = hol_find_entry (hol, name);
661 entry->group = group;
664 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
665 EQ is what to return if GROUP1 and GROUP2 are the same. */
667 group_cmp (int group1, int group2, int eq)
669 if (group1 == group2)
671 else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
672 return group1 - group2;
674 return group2 - group1;
677 /* Compare clusters CL1 & CL2 by the order that they should appear in
680 hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
682 /* If one cluster is deeper than the other, use its ancestor at the same
683 level, so that finding the common ancestor is straightforward.
685 clN->depth > 0 means that clN->parent != NULL (see hol_add_cluster) */
686 while (cl1->depth > cl2->depth)
688 while (cl2->depth > cl1->depth)
691 /* Now reduce both clusters to their ancestors at the point where both have
692 a common parent; these can be directly compared. */
693 while (cl1->parent != cl2->parent)
694 cl1 = cl1->parent, cl2 = cl2->parent;
696 return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
699 /* Return the ancestor of CL that's just below the root (i.e., has a parent
701 static struct hol_cluster *
702 hol_cluster_base (struct hol_cluster *cl)
709 /* Return true if CL1 is a child of CL2. */
711 hol_cluster_is_child (const struct hol_cluster *cl1,
712 const struct hol_cluster *cl2)
714 while (cl1 && cl1 != cl2)
719 /* Given the name of an OPTION_DOC option, modifies NAME to start at the tail
720 that should be used for comparisons, and returns true iff it should be
721 treated as a non-option. */
723 canon_doc_option (const char **name)
731 /* Skip initial whitespace. */
732 while (isspace ((unsigned char) **name))
734 /* Decide whether this looks like an option (leading '-') or not. */
735 non_opt = (**name != '-');
736 /* Skip until part of name used for sorting. */
737 while (**name && !isalnum ((unsigned char) **name))
743 #define HOL_ENTRY_PTRCMP(a,b) ((a)->ord < (b)->ord ? -1 : 1)
745 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
748 hol_entry_cmp (const struct hol_entry *entry1,
749 const struct hol_entry *entry2)
751 /* The group numbers by which the entries should be ordered; if either is
752 in a cluster, then this is just the group within the cluster. */
753 int group1 = entry1->group, group2 = entry2->group;
756 if (entry1->cluster != entry2->cluster)
758 /* The entries are not within the same cluster, so we can't compare them
759 directly, we have to use the appropriate clustering level too. */
760 if (! entry1->cluster)
761 /* ENTRY1 is at the "base level", not in a cluster, so we have to
762 compare it's group number with that of the base cluster in which
763 ENTRY2 resides. Note that if they're in the same group, the
764 clustered option always comes laster. */
765 return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
766 else if (! entry2->cluster)
767 /* Likewise, but ENTRY2's not in a cluster. */
768 return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
770 /* Both entries are in clusters, we can just compare the clusters. */
771 return (rc = hol_cluster_cmp (entry1->cluster, entry2->cluster)) ?
772 rc : HOL_ENTRY_PTRCMP (entry1, entry2);
774 else if (group1 == group2)
775 /* The entries are both in the same cluster and group, so compare them
778 int short1 = hol_entry_first_short (entry1);
779 int short2 = hol_entry_first_short (entry2);
780 int doc1 = odoc (entry1->opt);
781 int doc2 = odoc (entry2->opt);
782 const char *long1 = hol_entry_first_long (entry1);
783 const char *long2 = hol_entry_first_long (entry2);
786 doc1 = canon_doc_option (&long1);
788 doc2 = canon_doc_option (&long2);
791 /* "documentation" options always follow normal options (or
792 documentation options that *look* like normal options). */
794 else if (!short1 && !short2 && long1 && long2)
795 /* Only long options. */
796 return (rc = __strcasecmp (long1, long2)) ?
797 rc : HOL_ENTRY_PTRCMP (entry1, entry2);
799 /* Compare short/short, long/short, short/long, using the first
800 character of long options. Entries without *any* valid
801 options (such as options with OPTION_HIDDEN set) will be put
802 first, but as they're not displayed, it doesn't matter where
805 unsigned char first1 = short1 ? short1 : long1 ? *long1 : 0;
806 unsigned char first2 = short2 ? short2 : long2 ? *long2 : 0;
807 /* Use tolower, not _tolower, since only the former is
808 guaranteed to work on something already lower case. */
809 int lower_cmp = tolower (first1) - tolower (first2);
810 /* Compare ignoring case, except when the options are both the
811 same letter, in which case lower-case always comes first. */
812 return lower_cmp ? lower_cmp :
813 (rc = first2 - first1) ?
814 rc : HOL_ENTRY_PTRCMP (entry1, entry2);
818 /* Within the same cluster, but not the same group, so just compare
820 return group_cmp (group1, group2, HOL_ENTRY_PTRCMP (entry1, entry2));
823 /* Version of hol_entry_cmp with correct signature for qsort. */
825 hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
827 return hol_entry_cmp (entry1_v, entry2_v);
830 /* Sort HOL by group and alphabetically by option name (with short options
831 taking precedence over long). Since the sorting is for display purposes
832 only, the shadowing of options isn't effected. */
834 hol_sort (struct hol *hol)
836 if (hol->num_entries > 0)
840 for (i = 0, e = hol->entries; i < hol->num_entries; i++, e++)
842 qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
847 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
848 any in MORE with the same name. */
850 hol_append (struct hol *hol, struct hol *more)
852 struct hol_cluster **cl_end = &hol->clusters;
854 /* Steal MORE's cluster list, and add it to the end of HOL's. */
856 cl_end = &(*cl_end)->next;
857 *cl_end = more->clusters;
861 if (more->num_entries > 0)
863 if (hol->num_entries == 0)
865 hol->num_entries = more->num_entries;
866 hol->entries = more->entries;
867 hol->short_options = more->short_options;
868 more->num_entries = 0; /* Mark MORE's fields as invalid. */
871 /* Append the entries in MORE to those in HOL, taking care to only add
872 non-shadowed SHORT_OPTIONS values. */
877 unsigned num_entries = hol->num_entries + more->num_entries;
878 struct hol_entry *entries =
879 malloc (num_entries * sizeof (struct hol_entry));
880 unsigned hol_so_len = strlen (hol->short_options);
881 char *short_options =
882 malloc (hol_so_len + strlen (more->short_options) + 1);
884 assert (entries && short_options);
885 if (SIZE_MAX <= UINT_MAX)
886 assert (num_entries <= SIZE_MAX / sizeof (struct hol_entry));
888 __mempcpy (__mempcpy (entries, hol->entries,
889 hol->num_entries * sizeof (struct hol_entry)),
891 more->num_entries * sizeof (struct hol_entry));
893 __mempcpy (short_options, hol->short_options, hol_so_len);
895 /* Fix up the short options pointers from HOL. */
896 for (e = entries, left = hol->num_entries; left > 0; e++, left--)
898 short_options + (e->short_options - hol->short_options);
900 /* Now add the short options from MORE, fixing up its entries
902 so = short_options + hol_so_len;
903 more_so = more->short_options;
904 for (left = more->num_entries; left > 0; e++, left--)
907 const struct argp_option *opt;
909 e->short_options = so;
911 for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
914 if (oshort (opt) && ch == opt->key)
915 /* The next short option in MORE_SO, CH, is from OPT. */
917 if (! find_char (ch, short_options,
918 short_options + hol_so_len))
919 /* The short option CH isn't shadowed by HOL's options,
920 so add it to the sum. */
930 free (hol->short_options);
932 hol->entries = entries;
933 hol->num_entries = num_entries;
934 hol->short_options = short_options;
941 /* Inserts enough spaces to make sure STREAM is at column COL. */
943 indent_to (argp_fmtstream_t stream, unsigned col)
945 int needed = col - __argp_fmtstream_point (stream);
947 __argp_fmtstream_putc (stream, ' ');
950 /* Output to STREAM either a space, or a newline if there isn't room for at
951 least ENSURE characters before the right margin. */
953 space (argp_fmtstream_t stream, size_t ensure)
955 if (__argp_fmtstream_point (stream) + ensure
956 >= __argp_fmtstream_rmargin (stream))
957 __argp_fmtstream_putc (stream, '\n');
959 __argp_fmtstream_putc (stream, ' ');
962 /* If the option REAL has an argument, we print it in using the printf
963 format REQ_FMT or OPT_FMT depending on whether it's a required or
964 optional argument. */
966 arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
967 const char *domain, argp_fmtstream_t stream)
971 if (real->flags & OPTION_ARG_OPTIONAL)
972 __argp_fmtstream_printf (stream, opt_fmt,
973 dgettext (domain, real->arg));
975 __argp_fmtstream_printf (stream, req_fmt,
976 dgettext (domain, real->arg));
980 /* Helper functions for hol_entry_help. */
982 /* State used during the execution of hol_help. */
983 struct hol_help_state
985 /* PREV_ENTRY should contain the previous entry printed, or 0. */
986 struct hol_entry *prev_entry;
988 /* If an entry is in a different group from the previous one, and SEP_GROUPS
989 is true, then a blank line will be printed before any output. */
992 /* True if a duplicate option argument was suppressed (only ever set if
993 UPARAMS.dup_args is false). */
994 int suppressed_dup_arg;
997 /* Some state used while printing a help entry (used to communicate with
998 helper functions). See the doc for hol_entry_help for more info, as most
999 of the fields are copied from its arguments. */
1002 const struct hol_entry *entry;
1003 argp_fmtstream_t stream;
1004 struct hol_help_state *hhstate;
1006 /* True if nothing's been printed so far. */
1009 /* If non-zero, the state that was used to print this help. */
1010 const struct argp_state *state;
1013 /* If a user doc filter should be applied to DOC, do so. */
1015 filter_doc (const char *doc, int key, const struct argp *argp,
1016 const struct argp_state *state)
1018 if (argp->help_filter)
1019 /* We must apply a user filter to this output. */
1021 void *input = __argp_input (argp, state);
1022 return (*argp->help_filter) (key, doc, input);
1029 /* Prints STR as a header line, with the margin lines set appropriately, and
1030 notes the fact that groups should be separated with a blank line. ARGP is
1031 the argp that should dictate any user doc filtering to take place. Note
1032 that the previous wrap margin isn't restored, but the left margin is reset
1035 print_header (const char *str, const struct argp *argp,
1036 struct pentry_state *pest)
1038 const char *tstr = dgettext (argp->argp_domain, str);
1039 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
1045 if (pest->hhstate->prev_entry)
1046 /* Precede with a blank line. */
1047 __argp_fmtstream_putc (pest->stream, '\n');
1048 indent_to (pest->stream, uparams.header_col);
1049 __argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
1050 __argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
1051 __argp_fmtstream_puts (pest->stream, fstr);
1052 __argp_fmtstream_set_lmargin (pest->stream, 0);
1053 __argp_fmtstream_putc (pest->stream, '\n');
1056 pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
1060 free ((char *) fstr);
1063 /* Inserts a comma if this isn't the first item on the line, and then makes
1064 sure we're at least to column COL. If this *is* the first item on a line,
1065 prints any pending whitespace/headers that should precede this line. Also
1068 comma (unsigned col, struct pentry_state *pest)
1072 const struct hol_entry *pe = pest->hhstate->prev_entry;
1073 const struct hol_cluster *cl = pest->entry->cluster;
1075 if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
1076 __argp_fmtstream_putc (pest->stream, '\n');
1078 if (cl && cl->header && *cl->header
1080 || (pe->cluster != cl
1081 && !hol_cluster_is_child (pe->cluster, cl))))
1082 /* If we're changing clusters, then this must be the start of the
1083 ENTRY's cluster unless that is an ancestor of the previous one
1084 (in which case we had just popped into a sub-cluster for a bit).
1085 If so, then print the cluster's header line. */
1087 int old_wm = __argp_fmtstream_wmargin (pest->stream);
1088 print_header (cl->header, cl->argp, pest);
1089 __argp_fmtstream_set_wmargin (pest->stream, old_wm);
1095 __argp_fmtstream_puts (pest->stream, ", ");
1097 indent_to (pest->stream, col);
1100 /* Print help for ENTRY to STREAM. */
1102 hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
1103 argp_fmtstream_t stream, struct hol_help_state *hhstate)
1106 const struct argp_option *real = entry->opt, *opt;
1107 char *so = entry->short_options;
1108 int have_long_opt = 0; /* We have any long options. */
1109 /* Saved margins. */
1110 int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
1111 int old_wm = __argp_fmtstream_wmargin (stream);
1112 /* PEST is a state block holding some of our variables that we'd like to
1113 share with helper functions. */
1114 struct pentry_state pest;
1117 pest.stream = stream;
1118 pest.hhstate = hhstate;
1123 for (opt = real, num = entry->num; num > 0; opt++, num--)
1124 if (opt->name && ovisible (opt))
1130 /* First emit short options. */
1131 __argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
1132 for (opt = real, num = entry->num; num > 0; opt++, num--)
1133 if (oshort (opt) && opt->key == *so)
1134 /* OPT has a valid (non shadowed) short option. */
1138 comma (uparams.short_opt_col, &pest);
1139 __argp_fmtstream_putc (stream, '-');
1140 __argp_fmtstream_putc (stream, *so);
1141 if (!have_long_opt || uparams.dup_args)
1142 arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
1144 hhstate->suppressed_dup_arg = 1;
1149 /* Now, long options. */
1151 /* A "documentation" option. */
1153 __argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
1154 for (opt = real, num = entry->num; num > 0; opt++, num--)
1155 if (opt->name && *opt->name && ovisible (opt))
1157 comma (uparams.doc_opt_col, &pest);
1158 /* Calling dgettext here isn't quite right, since sorting will
1159 have been done on the original; but documentation options
1160 should be pretty rare anyway... */
1161 __argp_fmtstream_puts (stream,
1164 dgettext (state->root_argp->argp_domain,
1169 /* A real long option. */
1171 int first_long_opt = 1;
1173 __argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
1174 for (opt = real, num = entry->num; num > 0; opt++, num--)
1175 if (opt->name && ovisible (opt))
1177 comma (uparams.long_opt_col, &pest);
1178 __argp_fmtstream_printf (stream, "--%s", opt->name);
1179 if (first_long_opt || uparams.dup_args)
1180 arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
1183 hhstate->suppressed_dup_arg = 1;
1187 /* Next, documentation strings. */
1188 __argp_fmtstream_set_lmargin (stream, 0);
1192 /* Didn't print any switches, what's up? */
1193 if (!oshort (real) && !real->name)
1194 /* This is a group header, print it nicely. */
1195 print_header (real->doc, entry->argp, &pest);
1197 /* Just a totally shadowed option or null header; print nothing. */
1198 goto cleanup; /* Just return, after cleaning up. */
1202 const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
1204 const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
1207 unsigned int col = __argp_fmtstream_point (stream);
1209 __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
1210 __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
1212 if (col > (unsigned int) (uparams.opt_doc_col + 3))
1213 __argp_fmtstream_putc (stream, '\n');
1214 else if (col >= (unsigned int) uparams.opt_doc_col)
1215 __argp_fmtstream_puts (stream, " ");
1217 indent_to (stream, uparams.opt_doc_col);
1219 __argp_fmtstream_puts (stream, fstr);
1221 if (fstr && fstr != tstr)
1222 free ((char *) fstr);
1224 /* Reset the left margin. */
1225 __argp_fmtstream_set_lmargin (stream, 0);
1226 __argp_fmtstream_putc (stream, '\n');
1229 hhstate->prev_entry = entry;
1232 __argp_fmtstream_set_lmargin (stream, old_lm);
1233 __argp_fmtstream_set_wmargin (stream, old_wm);
1236 /* Output a long help message about the options in HOL to STREAM. */
1238 hol_help (struct hol *hol, const struct argp_state *state,
1239 argp_fmtstream_t stream)
1242 struct hol_entry *entry;
1243 struct hol_help_state hhstate = { 0, 0, 0 };
1245 for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
1246 hol_entry_help (entry, state, stream, &hhstate);
1248 if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
1250 const char *tstr = dgettext (state->root_argp->argp_domain, "\
1251 Mandatory or optional arguments to long options are also mandatory or \
1252 optional for any corresponding short options.");
1253 const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
1254 state ? state->root_argp : 0, state);
1257 __argp_fmtstream_putc (stream, '\n');
1258 __argp_fmtstream_puts (stream, fstr);
1259 __argp_fmtstream_putc (stream, '\n');
1261 if (fstr && fstr != tstr)
1262 free ((char *) fstr);
1266 /* Helper functions for hol_usage. */
1268 /* If OPT is a short option without an arg, append its key to the string
1269 pointer pointer to by COOKIE, and advance the pointer. */
1271 add_argless_short_opt (const struct argp_option *opt,
1272 const struct argp_option *real,
1273 const char *domain, void *cookie)
1275 char **snao_end = cookie;
1276 if (!(opt->arg || real->arg)
1277 && !((opt->flags | real->flags) & OPTION_NO_USAGE))
1278 *(*snao_end)++ = opt->key;
1282 /* If OPT is a short option with an arg, output a usage entry for it to the
1283 stream pointed at by COOKIE. */
1285 usage_argful_short_opt (const struct argp_option *opt,
1286 const struct argp_option *real,
1287 const char *domain, void *cookie)
1289 argp_fmtstream_t stream = cookie;
1290 const char *arg = opt->arg;
1291 int flags = opt->flags | real->flags;
1296 if (arg && !(flags & OPTION_NO_USAGE))
1298 arg = dgettext (domain, arg);
1300 if (flags & OPTION_ARG_OPTIONAL)
1301 __argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
1304 /* Manually do line wrapping so that it (probably) won't
1305 get wrapped at the embedded space. */
1306 space (stream, 6 + strlen (arg));
1307 __argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
1314 /* Output a usage entry for the long option opt to the stream pointed at by
1317 usage_long_opt (const struct argp_option *opt,
1318 const struct argp_option *real,
1319 const char *domain, void *cookie)
1321 argp_fmtstream_t stream = cookie;
1322 const char *arg = opt->arg;
1323 int flags = opt->flags | real->flags;
1328 if (! (flags & OPTION_NO_USAGE) && !odoc (opt))
1332 arg = dgettext (domain, arg);
1333 if (flags & OPTION_ARG_OPTIONAL)
1334 __argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
1336 __argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
1339 __argp_fmtstream_printf (stream, " [--%s]", opt->name);
1345 /* Print a short usage description for the arguments in HOL to STREAM. */
1347 hol_usage (struct hol *hol, argp_fmtstream_t stream)
1349 if (hol->num_entries > 0)
1352 struct hol_entry *entry;
1353 char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
1354 char *snao_end = short_no_arg_opts;
1356 /* First we put a list of short options without arguments. */
1357 for (entry = hol->entries, nentries = hol->num_entries
1359 ; entry++, nentries--)
1360 hol_entry_short_iterate (entry, add_argless_short_opt,
1361 entry->argp->argp_domain, &snao_end);
1362 if (snao_end > short_no_arg_opts)
1365 __argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
1368 /* Now a list of short options *with* arguments. */
1369 for (entry = hol->entries, nentries = hol->num_entries
1371 ; entry++, nentries--)
1372 hol_entry_short_iterate (entry, usage_argful_short_opt,
1373 entry->argp->argp_domain, stream);
1375 /* Finally, a list of long options (whew!). */
1376 for (entry = hol->entries, nentries = hol->num_entries
1378 ; entry++, nentries--)
1379 hol_entry_long_iterate (entry, usage_long_opt,
1380 entry->argp->argp_domain, stream);
1384 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1385 cluster in which ARGP's entries should be clustered, or 0. */
1387 argp_hol (const struct argp *argp, struct hol_cluster *cluster)
1389 const struct argp_child *child = argp->children;
1390 struct hol *hol = make_hol (argp, cluster);
1394 struct hol_cluster *child_cluster =
1395 ((child->group || child->header)
1396 /* Put CHILD->argp within its own cluster. */
1397 ? hol_add_cluster (hol, child->group, child->header,
1398 child - argp->children, cluster, argp)
1399 /* Just merge it into the parent's cluster. */
1401 hol_append (hol, argp_hol (child->argp, child_cluster)) ;
1407 /* Calculate how many different levels with alternative args strings exist in
1410 argp_args_levels (const struct argp *argp)
1413 const struct argp_child *child = argp->children;
1415 if (argp->args_doc && strchr (argp->args_doc, '\n'))
1420 levels += argp_args_levels ((child++)->argp);
1425 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1426 preceded by a space. LEVELS is a pointer to a byte vector the length
1427 returned by argp_args_levels; it should be initialized to zero, and
1428 updated by this routine for the next call if ADVANCE is true. True is
1429 returned as long as there are more patterns to output. */
1431 argp_args_usage (const struct argp *argp, const struct argp_state *state,
1432 char **levels, int advance, argp_fmtstream_t stream)
1434 char *our_level = *levels;
1436 const struct argp_child *child = argp->children;
1437 const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
1438 const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
1442 const char *cp = fdoc;
1443 nl = __strchrnul (cp, '\n');
1445 /* This is a "multi-level" args doc; advance to the correct position
1446 as determined by our state in LEVELS, and update LEVELS. */
1450 for (i = 0; i < *our_level; i++)
1451 cp = nl + 1, nl = __strchrnul (cp, '\n');
1455 /* Manually do line wrapping so that it (probably) won't get wrapped at
1456 any embedded spaces. */
1457 space (stream, 1 + nl - cp);
1459 __argp_fmtstream_write (stream, cp, nl - cp);
1461 if (fdoc && fdoc != tdoc)
1462 free ((char *)fdoc); /* Free user's modified doc string. */
1466 advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
1468 if (advance && multiple)
1470 /* Need to increment our level. */
1472 /* There's more we can do here. */
1475 advance = 0; /* Our parent shouldn't advance also. */
1477 else if (*our_level > 0)
1478 /* We had multiple levels, but used them up; reset to zero. */
1485 /* Print the documentation for ARGP to STREAM; if POST is false, then
1486 everything preceding a '\v' character in the documentation strings (or
1487 the whole string, for those with none) is printed, otherwise, everything
1488 following the '\v' character (nothing for strings without). Each separate
1489 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1490 then the first is as well. If FIRST_ONLY is true, only the first
1491 occurrence is output. Returns true if anything was output. */
1493 argp_doc (const struct argp *argp, const struct argp_state *state,
1494 int post, int pre_blank, int first_only,
1495 argp_fmtstream_t stream)
1498 const char *inp_text;
1499 size_t inp_text_len = 0;
1500 const char *trans_text;
1503 const struct argp_child *child = argp->children;
1507 char *vt = strchr (argp->doc, '\v');
1514 inp_text_len = vt - argp->doc;
1515 inp_text = __strndup (argp->doc, inp_text_len);
1519 inp_text = post ? 0 : argp->doc;
1520 trans_text = inp_text ? dgettext (argp->argp_domain, inp_text) : NULL;
1523 trans_text = inp_text = 0;
1525 if (argp->help_filter)
1526 /* We have to filter the doc strings. */
1528 input = __argp_input (argp, state);
1530 (*argp->help_filter) (post
1531 ? ARGP_KEY_HELP_POST_DOC
1532 : ARGP_KEY_HELP_PRE_DOC,
1536 text = (const char *) trans_text;
1541 __argp_fmtstream_putc (stream, '\n');
1543 __argp_fmtstream_puts (stream, text);
1545 if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
1546 __argp_fmtstream_putc (stream, '\n');
1551 if (text && text != trans_text)
1552 free ((char *) text); /* Free TEXT returned from the help filter. */
1554 if (inp_text && inp_text_len)
1555 free ((char *) inp_text); /* We copied INP_TEXT, so free it now. */
1557 if (post && argp->help_filter)
1558 /* Now see if we have to output an ARGP_KEY_HELP_EXTRA text. */
1560 text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
1563 if (anything || pre_blank)
1564 __argp_fmtstream_putc (stream, '\n');
1565 __argp_fmtstream_puts (stream, text);
1566 free ((char *) text);
1567 if (__argp_fmtstream_point (stream)
1568 > __argp_fmtstream_lmargin (stream))
1569 __argp_fmtstream_putc (stream, '\n');
1575 while (child->argp && !(first_only && anything))
1577 argp_doc ((child++)->argp, state,
1578 post, anything || pre_blank, first_only,
1584 /* Output a usage message for ARGP to STREAM. If called from
1585 argp_state_help, STATE is the relevant parsing state. FLAGS are from the
1586 set ARGP_HELP_*. NAME is what to use wherever a "program name" is
1589 _help (const struct argp *argp, const struct argp_state *state, FILE *stream,
1590 unsigned flags, char *name)
1592 int anything = 0; /* Whether we've output anything. */
1593 struct hol *hol = 0;
1594 argp_fmtstream_t fs;
1599 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1600 __flockfile (stream);
1603 if (! uparams.valid)
1604 fill_in_uparams (state);
1606 fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
1609 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1610 __funlockfile (stream);
1615 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
1617 hol = argp_hol (argp, 0);
1619 /* If present, these options always come last. */
1620 hol_set_group (hol, "help", -1);
1621 hol_set_group (hol, "version", -1);
1626 if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
1627 /* Print a short "Usage:" message. */
1629 int first_pattern = 1, more_patterns;
1630 size_t num_pattern_levels = argp_args_levels (argp);
1631 char *pattern_levels = alloca (num_pattern_levels);
1633 memset (pattern_levels, 0, num_pattern_levels);
1638 int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
1639 char *levels = pattern_levels;
1642 __argp_fmtstream_printf (fs, "%s %s",
1643 dgettext (argp->argp_domain, "Usage:"),
1646 __argp_fmtstream_printf (fs, "%s %s",
1647 dgettext (argp->argp_domain, " or: "),
1650 /* We set the lmargin as well as the wmargin, because hol_usage
1651 manually wraps options with newline to avoid annoying breaks. */
1652 old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
1654 if (flags & ARGP_HELP_SHORT_USAGE)
1655 /* Just show where the options go. */
1657 if (hol->num_entries > 0)
1658 __argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
1662 /* Actually print the options. */
1664 hol_usage (hol, fs);
1665 flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once. */
1668 more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
1670 __argp_fmtstream_set_wmargin (fs, old_wm);
1671 __argp_fmtstream_set_lmargin (fs, old_lm);
1673 __argp_fmtstream_putc (fs, '\n');
1678 while (more_patterns);
1681 if (flags & ARGP_HELP_PRE_DOC)
1682 anything |= argp_doc (argp, state, 0, 0, 1, fs);
1684 if (flags & ARGP_HELP_SEE)
1686 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
1687 Try '%s --help' or '%s --usage' for more information.\n"),
1692 if (flags & ARGP_HELP_LONG)
1693 /* Print a long, detailed help message. */
1695 /* Print info about all the options. */
1696 if (hol->num_entries > 0)
1699 __argp_fmtstream_putc (fs, '\n');
1700 hol_help (hol, state, fs);
1705 if (flags & ARGP_HELP_POST_DOC)
1706 /* Print any documentation strings at the end. */
1707 anything |= argp_doc (argp, state, 1, anything, 0, fs);
1709 if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
1712 __argp_fmtstream_putc (fs, '\n');
1713 __argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
1714 "Report bugs to %s.\n"),
1715 argp_program_bug_address);
1719 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1720 __funlockfile (stream);
1726 __argp_fmtstream_free (fs);
1729 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1730 ARGP_HELP_*. NAME is what to use wherever a "program name" is needed. */
1731 void __argp_help (const struct argp *argp, FILE *stream,
1732 unsigned flags, char *name)
1734 struct argp_state state;
1735 memset (&state, 0, sizeof state);
1736 state.root_argp = argp;
1737 _help (argp, &state, stream, flags, name);
1740 weak_alias (__argp_help, argp_help)
1743 #if ! (defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME)
1745 __argp_short_program_name (void)
1747 # if HAVE_DECL_PROGRAM_INVOCATION_NAME
1748 return __argp_base_name (program_invocation_name);
1750 /* FIXME: What now? Miles suggests that it is better to use NULL,
1751 but currently the value is passed on directly to fputs_unlocked,
1752 so that requires more changes. */
1754 # warning No reasonable value to return
1755 # endif /* __GNUC__ */
1761 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1762 from the set ARGP_HELP_*. */
1764 __argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
1766 if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
1768 if (state && (state->flags & ARGP_LONG_ONLY))
1769 flags |= ARGP_HELP_LONG_ONLY;
1771 _help (state ? state->root_argp : 0, state, stream, flags,
1772 state ? state->name : __argp_short_program_name ());
1774 if (!state || ! (state->flags & ARGP_NO_EXIT))
1776 if (flags & ARGP_HELP_EXIT_ERR)
1777 exit (argp_err_exit_status);
1778 if (flags & ARGP_HELP_EXIT_OK)
1784 weak_alias (__argp_state_help, argp_state_help)
1787 /* If appropriate, print the printf string FMT and following args, preceded
1788 by the program name and ':', to stderr, and followed by a "Try ... --help"
1789 message, then exit (1). */
1791 __argp_error (const struct argp_state *state, const char *fmt, ...)
1793 if (!state || !(state->flags & ARGP_NO_ERRS))
1795 FILE *stream = state ? state->err_stream : stderr;
1801 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1802 __flockfile (stream);
1808 if (_IO_fwide (stream, 0) > 0)
1812 if (__asprintf (&buf, fmt, ap) < 0)
1815 __fwprintf (stream, L"%s: %s\n",
1816 state ? state->name : __argp_short_program_name (),
1824 fputs_unlocked (state
1825 ? state->name : __argp_short_program_name (),
1827 putc_unlocked (':', stream);
1828 putc_unlocked (' ', stream);
1830 vfprintf (stream, fmt, ap);
1832 putc_unlocked ('\n', stream);
1835 __argp_state_help (state, stream, ARGP_HELP_STD_ERR);
1839 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1840 __funlockfile (stream);
1846 weak_alias (__argp_error, argp_error)
1849 /* Similar to the standard gnu error-reporting function error(), but will
1850 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1851 to STATE->err_stream. This is useful for argument parsing code that is
1852 shared between program startup (when exiting is desired) and runtime
1853 option parsing (when typically an error code is returned instead). The
1854 difference between this function and argp_error is that the latter is for
1855 *parsing errors*, and the former is for other problems that occur during
1856 parsing but don't reflect a (syntactic) problem with the input. */
1858 __argp_failure (const struct argp_state *state, int status, int errnum,
1859 const char *fmt, ...)
1861 if (!state || !(state->flags & ARGP_NO_ERRS))
1863 FILE *stream = state ? state->err_stream : stderr;
1867 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1868 __flockfile (stream);
1872 if (_IO_fwide (stream, 0) > 0)
1873 __fwprintf (stream, L"%s",
1874 state ? state->name : __argp_short_program_name ());
1877 fputs_unlocked (state
1878 ? state->name : __argp_short_program_name (),
1887 if (_IO_fwide (stream, 0) > 0)
1891 if (__asprintf (&buf, fmt, ap) < 0)
1894 __fwprintf (stream, L": %s", buf);
1901 putc_unlocked (':', stream);
1902 putc_unlocked (' ', stream);
1904 vfprintf (stream, fmt, ap);
1915 if (_IO_fwide (stream, 0) > 0)
1916 __fwprintf (stream, L": %s",
1917 __strerror_r (errnum, buf, sizeof (buf)));
1921 char const *s = NULL;
1922 putc_unlocked (':', stream);
1923 putc_unlocked (' ', stream);
1924 #if _LIBC || (HAVE_DECL_STRERROR_R && STRERROR_R_CHAR_P && !defined strerror_r)
1925 s = __strerror_r (errnum, buf, sizeof buf);
1926 #elif HAVE_DECL_STRERROR_R
1927 if (__strerror_r (errnum, buf, sizeof buf) == 0)
1931 if (! s && ! (s = strerror (errnum)))
1932 s = dgettext (state->root_argp->argp_domain,
1933 "Unknown system error");
1940 if (_IO_fwide (stream, 0) > 0)
1941 putwc_unlocked (L'\n', stream);
1944 putc_unlocked ('\n', stream);
1946 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1947 __funlockfile (stream);
1950 if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
1956 weak_alias (__argp_failure, argp_failure)