1
/* Hierarchial argument parsing help output
2
Copyright (C) 1995-2005, 2007, 2009-2010 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 3 of the License, or
9
(at your option) any later version.
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
17
along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
# define _GNU_SOURCE 1
43
# define dgettext(domain, msgid) \
44
INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
50
#include "argp-fmtstream.h"
51
#include "argp-namefrob.h"
54
# define SIZE_MAX ((size_t) -1)
57
/* User-selectable (using an environment variable) formatting parameters.
59
These may be specified in an environment variable called `ARGP_HELP_FMT',
60
with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
61
Where VALn must be a positive integer. The list of variables is in the
62
UPARAM_NAMES vector, below. */
64
/* Default parameters. */
65
#define DUP_ARGS 0 /* True if option argument can be duplicated. */
66
#define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
67
#define SHORT_OPT_COL 2 /* column in which short options start */
68
#define LONG_OPT_COL 6 /* column in which long options start */
69
#define DOC_OPT_COL 2 /* column in which doc options start */
70
#define OPT_DOC_COL 29 /* column in which option text starts */
71
#define HEADER_COL 1 /* column in which group headers are printed */
72
#define USAGE_INDENT 12 /* indentation of wrapped usage lines */
73
#define RMARGIN 79 /* right margin used for wrapping */
75
/* User-selectable (using an environment variable) formatting parameters.
76
They must all be of type `int' for the parsing code to work. */
79
/* If true, arguments for an option are shown with both short and long
80
options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
81
If false, then if an option has both, the argument is only shown with
82
the long one, e.g., `-x, --longx=ARG', and a message indicating that
83
this really means both is printed below the options. */
86
/* This is true if when DUP_ARGS is false, and some duplicate arguments have
87
been suppressed, an explanatory message should be printed. */
90
/* Various output columns. */
91
int short_opt_col; /* column in which short options start */
92
int long_opt_col; /* column in which long options start */
93
int doc_opt_col; /* column in which doc options start */
94
int opt_doc_col; /* column in which option text starts */
95
int header_col; /* column in which group headers are printed */
96
int usage_indent; /* indentation of wrapped usage lines */
97
int rmargin; /* right margin used for wrapping */
99
int valid; /* True when the values in here are valid. */
102
/* This is a global variable, as user options are only ever read once. */
103
static struct uparams uparams = {
104
DUP_ARGS, DUP_ARGS_NOTE,
105
SHORT_OPT_COL, LONG_OPT_COL, DOC_OPT_COL, OPT_DOC_COL, HEADER_COL,
106
USAGE_INDENT, RMARGIN,
110
/* A particular uparam, and what the user name is. */
113
const char *name; /* User name. */
114
int is_bool; /* Whether it's `boolean'. */
115
size_t uparams_offs; /* Location of the (int) field in UPARAMS. */
118
/* The name-field mappings we know about. */
119
static const struct uparam_name uparam_names[] =
121
{ "dup-args", 1, offsetof (struct uparams, dup_args) },
122
{ "dup-args-note", 1, offsetof (struct uparams, dup_args_note) },
123
{ "short-opt-col", 0, offsetof (struct uparams, short_opt_col) },
124
{ "long-opt-col", 0, offsetof (struct uparams, long_opt_col) },
125
{ "doc-opt-col", 0, offsetof (struct uparams, doc_opt_col) },
126
{ "opt-doc-col", 0, offsetof (struct uparams, opt_doc_col) },
127
{ "header-col", 0, offsetof (struct uparams, header_col) },
128
{ "usage-indent", 0, offsetof (struct uparams, usage_indent) },
129
{ "rmargin", 0, offsetof (struct uparams, rmargin) },
134
validate_uparams (const struct argp_state *state, struct uparams *upptr)
136
const struct uparam_name *up;
138
for (up = uparam_names; up->name; up++)
141
|| up->uparams_offs == offsetof (struct uparams, rmargin))
143
if (*(int *)((char *)upptr + up->uparams_offs) >= upptr->rmargin)
145
__argp_failure (state, 0, 0,
146
dgettext (state->root_argp->argp_domain,
148
ARGP_HELP_FMT: %s value is less than or equal to %s"),
149
"rmargin", up->name);
157
/* Read user options from the environment, and fill in UPARAMS appropiately. */
159
fill_in_uparams (const struct argp_state *state)
161
const char *var = getenv ("ARGP_HELP_FMT");
162
struct uparams new_params = uparams;
164
#define SKIPWS(p) do { while (isspace ((unsigned char) *p)) p++; } while (0);
173
if (isalpha ((unsigned char) *var))
176
const struct uparam_name *un;
177
int unspec = 0, val = 0;
178
const char *arg = var;
180
while (isalnum ((unsigned char) *arg) || *arg == '-' || *arg == '_')
186
if (*arg == '\0' || *arg == ',')
188
else if (*arg == '=')
196
if (var[0] == 'n' && var[1] == 'o' && var[2] == '-')
205
else if (isdigit ((unsigned char) *arg))
208
while (isdigit ((unsigned char) *arg))
213
for (un = uparam_names; un->name; un++)
214
if (strlen (un->name) == var_len
215
&& strncmp (var, un->name, var_len) == 0)
217
if (unspec && !un->is_bool)
218
__argp_failure (state, 0, 0,
219
dgettext (state->root_argp->argp_domain,
221
%.*s: ARGP_HELP_FMT parameter requires a value"),
224
__argp_failure (state, 0, 0,
225
dgettext (state->root_argp->argp_domain,
227
%.*s: ARGP_HELP_FMT parameter must be positive"),
230
*(int *)((char *)&new_params + un->uparams_offs) = val;
234
__argp_failure (state, 0, 0,
235
dgettext (state->root_argp->argp_domain, "\
236
%.*s: Unknown ARGP_HELP_FMT parameter"),
245
__argp_failure (state, 0, 0,
246
dgettext (state->root_argp->argp_domain,
247
"Garbage in ARGP_HELP_FMT: %s"), var);
251
validate_uparams (state, &new_params);
255
/* Returns true if OPT hasn't been marked invisible. Visibility only affects
256
whether OPT is displayed or used in sorting, not option shadowing. */
257
#define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
259
/* Returns true if OPT is an alias for an earlier option. */
260
#define oalias(opt) ((opt)->flags & OPTION_ALIAS)
262
/* Returns true if OPT is an documentation-only entry. */
263
#define odoc(opt) ((opt)->flags & OPTION_DOC)
265
/* Returns true if OPT should not be translated */
266
#define onotrans(opt) ((opt)->flags & OPTION_NO_TRANS)
268
/* Returns true if OPT is the end-of-list marker for a list of options. */
269
#define oend(opt) __option_is_end (opt)
271
/* Returns true if OPT has a short option. */
272
#define oshort(opt) __option_is_short (opt)
275
The help format for a particular option is like:
277
-xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
279
Where ARG will be omitted if there's no argument, for this option, or
280
will be surrounded by "[" and "]" appropiately if the argument is
281
optional. The documentation string is word-wrapped appropiately, and if
282
the list of options is long enough, it will be started on a separate line.
283
If there are no short options for a given option, the first long option is
284
indented slighly in a way that's supposed to make most long options appear
285
to be in a separate column.
287
For example, the following output (from ps):
289
-p PID, --pid=PID List the process PID
290
--pgrp=PGRP List processes in the process group PGRP
291
-P, -x, --no-parent Include processes without parents
292
-Q, --all-fields Don't elide unusable fields (normally if there's
293
some reason ps can't print a field for any
294
process, it's removed from the output entirely)
295
-r, --reverse, --gratuitously-long-reverse-option
296
Reverse the order of any sort
297
--session[=SID] Add the processes from the session SID (which
298
defaults to the sid of the current process)
300
Here are some more options:
301
-f ZOT, --foonly=ZOT Glork a foonly
302
-z, --zaza Snit a zar
304
-?, --help Give this help list
305
--usage Give a short usage message
306
-V, --version Print program version
308
The struct argp_option array for the above could look like:
311
{"pid", 'p', "PID", 0, "List the process PID"},
312
{"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
313
{"no-parent", 'P', 0, 0, "Include processes without parents"},
314
{0, 'x', 0, OPTION_ALIAS},
315
{"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
316
" if there's some reason ps can't"
317
" print a field for any process, it's"
318
" removed from the output entirely)" },
319
{"reverse", 'r', 0, 0, "Reverse the order of any sort"},
320
{"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
321
{"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
322
"Add the processes from the session"
323
" SID (which defaults to the sid of"
324
" the current process)" },
326
{0,0,0,0, "Here are some more options:"},
327
{"foonly", 'f', "ZOT", 0, "Glork a foonly"},
328
{"zaza", 'z', 0, 0, "Snit a zar"},
333
Note that the last three options are automatically supplied by argp_parse,
334
unless you tell it not to with ARGP_NO_HELP.
338
/* Returns true if CH occurs between BEG and END. */
340
find_char (char ch, char *beg, char *end)
350
struct hol_cluster; /* fwd decl */
355
const struct argp_option *opt;
356
/* Number of options (including aliases). */
359
/* A pointers into the HOL's short_options field, to the first short option
360
letter for this entry. The order of the characters following this point
361
corresponds to the order of options pointed to by OPT, and there are at
362
most NUM. A short option recorded in a option following OPT is only
363
valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
364
probably been shadowed by some other entry). */
367
/* Entries are sorted by their group first, in the order:
368
1, 2, ..., n, 0, -m, ..., -2, -1
369
and then alphabetically within each group. The default is 0. */
372
/* The cluster of options this entry belongs to, or 0 if none. */
373
struct hol_cluster *cluster;
375
/* The argp from which this option came. */
376
const struct argp *argp;
378
/* Position in the array */
382
/* A cluster of entries to reflect the argp tree structure. */
385
/* A descriptive header printed before options in this cluster. */
388
/* Used to order clusters within the same group with the same parent,
389
according to the order in which they occurred in the parent argp's child
393
/* How to sort this cluster with respect to options and other clusters at the
394
same depth (clusters always follow options in the same group). */
397
/* The cluster to which this cluster belongs, or 0 if it's at the base
399
struct hol_cluster *parent;
401
/* The argp from which this cluster is (eventually) derived. */
402
const struct argp *argp;
404
/* The distance this cluster is from the root. */
407
/* Clusters in a given hol are kept in a linked list, to make freeing them
409
struct hol_cluster *next;
412
/* A list of options for help. */
415
/* An array of hol_entry's. */
416
struct hol_entry *entries;
417
/* The number of entries in this hol. If this field is zero, the others
419
unsigned num_entries;
421
/* A string containing all short options in this HOL. Each entry contains
422
pointers into this string, so the order can't be messed with blindly. */
425
/* Clusters of entries in this hol. */
426
struct hol_cluster *clusters;
429
/* Create a struct hol from the options in ARGP. CLUSTER is the
430
hol_cluster in which these entries occur, or 0, if at the root. */
432
make_hol (const struct argp *argp, struct hol_cluster *cluster)
435
const struct argp_option *o;
436
const struct argp_option *opts = argp->options;
437
struct hol_entry *entry;
438
unsigned num_short_options = 0;
439
struct hol *hol = malloc (sizeof (struct hol));
443
hol->num_entries = 0;
450
/* The first option must not be an alias. */
451
assert (! oalias (opts));
453
/* Calculate the space needed. */
454
for (o = opts; ! oend (o); o++)
459
num_short_options++; /* This is an upper bound. */
462
hol->entries = malloc (sizeof (struct hol_entry) * hol->num_entries);
463
hol->short_options = malloc (num_short_options + 1);
465
assert (hol->entries && hol->short_options);
466
if (SIZE_MAX <= UINT_MAX)
467
assert (hol->num_entries <= SIZE_MAX / sizeof (struct hol_entry));
469
/* Fill in the entries. */
470
so = hol->short_options;
471
for (o = opts, entry = hol->entries; ! oend (o); entry++)
475
entry->short_options = so;
476
entry->group = cur_group =
479
: ((!o->name && !o->key)
482
entry->cluster = cluster;
488
if (oshort (o) && ! find_char (o->key, hol->short_options, so))
489
/* O has a valid short option which hasn't already been used.*/
493
while (! oend (o) && oalias (o));
495
*so = '\0'; /* null terminated so we can find the length */
501
/* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
502
associated argp child list entry), INDEX, and PARENT, and return a pointer
503
to it. ARGP is the argp that this cluster results from. */
504
static struct hol_cluster *
505
hol_add_cluster (struct hol *hol, int group, const char *header, int index,
506
struct hol_cluster *parent, const struct argp *argp)
508
struct hol_cluster *cl = malloc (sizeof (struct hol_cluster));
517
cl->depth = parent ? parent->depth + 1 : 0;
519
cl->next = hol->clusters;
525
/* Free HOL and any resources it uses. */
527
hol_free (struct hol *hol)
529
struct hol_cluster *cl = hol->clusters;
533
struct hol_cluster *next = cl->next;
538
if (hol->num_entries > 0)
541
free (hol->short_options);
548
hol_entry_short_iterate (const struct hol_entry *entry,
549
int (*func)(const struct argp_option *opt,
550
const struct argp_option *real,
551
const char *domain, void *cookie),
552
const char *domain, void *cookie)
556
const struct argp_option *opt, *real = entry->opt;
557
char *so = entry->short_options;
559
for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
560
if (oshort (opt) && *so == opt->key)
565
val = (*func)(opt, real, domain, cookie);
573
__attribute__ ((always_inline))
574
hol_entry_long_iterate (const struct hol_entry *entry,
575
int (*func)(const struct argp_option *opt,
576
const struct argp_option *real,
577
const char *domain, void *cookie),
578
const char *domain, void *cookie)
582
const struct argp_option *opt, *real = entry->opt;
584
for (opt = real, nopts = entry->num; nopts > 0 && !val; opt++, nopts--)
590
val = (*func)(opt, real, domain, cookie);
596
/* Iterator that returns true for the first short option. */
598
until_short (const struct argp_option *opt, const struct argp_option *real,
599
const char *domain, void *cookie)
601
return oshort (opt) ? opt->key : 0;
604
/* Returns the first valid short option in ENTRY, or 0 if there is none. */
606
hol_entry_first_short (const struct hol_entry *entry)
608
return hol_entry_short_iterate (entry, until_short,
609
entry->argp->argp_domain, 0);
612
/* Returns the first valid long option in ENTRY, or 0 if there is none. */
614
hol_entry_first_long (const struct hol_entry *entry)
616
const struct argp_option *opt;
618
for (opt = entry->opt, num = entry->num; num > 0; opt++, num--)
619
if (opt->name && ovisible (opt))
624
/* Returns the entry in HOL with the long option name NAME, or 0 if there is
626
static struct hol_entry *
627
hol_find_entry (struct hol *hol, const char *name)
629
struct hol_entry *entry = hol->entries;
630
unsigned num_entries = hol->num_entries;
632
while (num_entries-- > 0)
634
const struct argp_option *opt = entry->opt;
635
unsigned num_opts = entry->num;
637
while (num_opts-- > 0)
638
if (opt->name && ovisible (opt) && strcmp (opt->name, name) == 0)
649
/* If an entry with the long option NAME occurs in HOL, set it's special
650
sort position to GROUP. */
652
hol_set_group (struct hol *hol, const char *name, int group)
654
struct hol_entry *entry = hol_find_entry (hol, name);
656
entry->group = group;
659
/* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
660
EQ is what to return if GROUP1 and GROUP2 are the same. */
662
group_cmp (int group1, int group2, int eq)
664
if (group1 == group2)
666
else if ((group1 < 0 && group2 < 0) || (group1 >= 0 && group2 >= 0))
667
return group1 - group2;
669
return group2 - group1;
672
/* Compare clusters CL1 & CL2 by the order that they should appear in
675
hol_cluster_cmp (const struct hol_cluster *cl1, const struct hol_cluster *cl2)
677
/* If one cluster is deeper than the other, use its ancestor at the same
678
level, so that finding the common ancestor is straightforward.
680
clN->depth > 0 means that clN->parent != NULL (see hol_add_cluster) */
681
while (cl1->depth > cl2->depth)
683
while (cl2->depth > cl1->depth)
686
/* Now reduce both clusters to their ancestors at the point where both have
687
a common parent; these can be directly compared. */
688
while (cl1->parent != cl2->parent)
689
cl1 = cl1->parent, cl2 = cl2->parent;
691
return group_cmp (cl1->group, cl2->group, cl2->index - cl1->index);
694
/* Return the ancestor of CL that's just below the root (i.e., has a parent
696
static struct hol_cluster *
697
hol_cluster_base (struct hol_cluster *cl)
704
/* Return true if CL1 is a child of CL2. */
706
hol_cluster_is_child (const struct hol_cluster *cl1,
707
const struct hol_cluster *cl2)
709
while (cl1 && cl1 != cl2)
714
/* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
715
that should be used for comparisons, and returns true iff it should be
716
treated as a non-option. */
718
canon_doc_option (const char **name)
726
/* Skip initial whitespace. */
727
while (isspace ((unsigned char) **name))
729
/* Decide whether this looks like an option (leading `-') or not. */
730
non_opt = (**name != '-');
731
/* Skip until part of name used for sorting. */
732
while (**name && !isalnum ((unsigned char) **name))
738
#define HOL_ENTRY_PTRCMP(a,b) ((a)->ord < (b)->ord ? -1 : 1)
740
/* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
743
hol_entry_cmp (const struct hol_entry *entry1,
744
const struct hol_entry *entry2)
746
/* The group numbers by which the entries should be ordered; if either is
747
in a cluster, then this is just the group within the cluster. */
748
int group1 = entry1->group, group2 = entry2->group;
751
if (entry1->cluster != entry2->cluster)
753
/* The entries are not within the same cluster, so we can't compare them
754
directly, we have to use the appropiate clustering level too. */
755
if (! entry1->cluster)
756
/* ENTRY1 is at the `base level', not in a cluster, so we have to
757
compare it's group number with that of the base cluster in which
758
ENTRY2 resides. Note that if they're in the same group, the
759
clustered option always comes laster. */
760
return group_cmp (group1, hol_cluster_base (entry2->cluster)->group, -1);
761
else if (! entry2->cluster)
762
/* Likewise, but ENTRY2's not in a cluster. */
763
return group_cmp (hol_cluster_base (entry1->cluster)->group, group2, 1);
765
/* Both entries are in clusters, we can just compare the clusters. */
766
return (rc = hol_cluster_cmp (entry1->cluster, entry2->cluster)) ?
767
rc : HOL_ENTRY_PTRCMP (entry1, entry2);
769
else if (group1 == group2)
770
/* The entries are both in the same cluster and group, so compare them
773
int short1 = hol_entry_first_short (entry1);
774
int short2 = hol_entry_first_short (entry2);
775
int doc1 = odoc (entry1->opt);
776
int doc2 = odoc (entry2->opt);
777
const char *long1 = hol_entry_first_long (entry1);
778
const char *long2 = hol_entry_first_long (entry2);
781
doc1 = canon_doc_option (&long1);
783
doc2 = canon_doc_option (&long2);
786
/* `documentation' options always follow normal options (or
787
documentation options that *look* like normal options). */
789
else if (!short1 && !short2 && long1 && long2)
790
/* Only long options. */
791
return (rc = __strcasecmp (long1, long2)) ?
792
rc : HOL_ENTRY_PTRCMP (entry1, entry2);
794
/* Compare short/short, long/short, short/long, using the first
795
character of long options. Entries without *any* valid
796
options (such as options with OPTION_HIDDEN set) will be put
797
first, but as they're not displayed, it doesn't matter where
800
unsigned char first1 = short1 ? short1 : long1 ? *long1 : 0;
801
unsigned char first2 = short2 ? short2 : long2 ? *long2 : 0;
802
/* Use tolower, not _tolower, since only the former is
803
guaranteed to work on something already lower case. */
804
int lower_cmp = tolower (first1) - tolower (first2);
805
/* Compare ignoring case, except when the options are both the
806
same letter, in which case lower-case always comes first. */
807
return lower_cmp ? lower_cmp :
808
(rc = first2 - first1) ?
809
rc : HOL_ENTRY_PTRCMP (entry1, entry2);
813
/* Within the same cluster, but not the same group, so just compare
815
return group_cmp (group1, group2, HOL_ENTRY_PTRCMP (entry1, entry2));
818
/* Version of hol_entry_cmp with correct signature for qsort. */
820
hol_entry_qcmp (const void *entry1_v, const void *entry2_v)
822
return hol_entry_cmp (entry1_v, entry2_v);
825
/* Sort HOL by group and alphabetically by option name (with short options
826
taking precedence over long). Since the sorting is for display purposes
827
only, the shadowing of options isn't effected. */
829
hol_sort (struct hol *hol)
831
if (hol->num_entries > 0)
835
for (i = 0, e = hol->entries; i < hol->num_entries; i++, e++)
837
qsort (hol->entries, hol->num_entries, sizeof (struct hol_entry),
842
/* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
843
any in MORE with the same name. */
845
hol_append (struct hol *hol, struct hol *more)
847
struct hol_cluster **cl_end = &hol->clusters;
849
/* Steal MORE's cluster list, and add it to the end of HOL's. */
851
cl_end = &(*cl_end)->next;
852
*cl_end = more->clusters;
856
if (more->num_entries > 0)
858
if (hol->num_entries == 0)
860
hol->num_entries = more->num_entries;
861
hol->entries = more->entries;
862
hol->short_options = more->short_options;
863
more->num_entries = 0; /* Mark MORE's fields as invalid. */
866
/* Append the entries in MORE to those in HOL, taking care to only add
867
non-shadowed SHORT_OPTIONS values. */
872
unsigned num_entries = hol->num_entries + more->num_entries;
873
struct hol_entry *entries =
874
malloc (num_entries * sizeof (struct hol_entry));
875
unsigned hol_so_len = strlen (hol->short_options);
876
char *short_options =
877
malloc (hol_so_len + strlen (more->short_options) + 1);
879
assert (entries && short_options);
880
if (SIZE_MAX <= UINT_MAX)
881
assert (num_entries <= SIZE_MAX / sizeof (struct hol_entry));
883
__mempcpy (__mempcpy (entries, hol->entries,
884
hol->num_entries * sizeof (struct hol_entry)),
886
more->num_entries * sizeof (struct hol_entry));
888
__mempcpy (short_options, hol->short_options, hol_so_len);
890
/* Fix up the short options pointers from HOL. */
891
for (e = entries, left = hol->num_entries; left > 0; e++, left--)
892
e->short_options += (short_options - hol->short_options);
894
/* Now add the short options from MORE, fixing up its entries
896
so = short_options + hol_so_len;
897
more_so = more->short_options;
898
for (left = more->num_entries; left > 0; e++, left--)
901
const struct argp_option *opt;
903
e->short_options = so;
905
for (opts_left = e->num, opt = e->opt; opts_left; opt++, opts_left--)
908
if (oshort (opt) && ch == opt->key)
909
/* The next short option in MORE_SO, CH, is from OPT. */
911
if (! find_char (ch, short_options,
912
short_options + hol_so_len))
913
/* The short option CH isn't shadowed by HOL's options,
914
so add it to the sum. */
924
free (hol->short_options);
926
hol->entries = entries;
927
hol->num_entries = num_entries;
928
hol->short_options = short_options;
935
/* Inserts enough spaces to make sure STREAM is at column COL. */
937
indent_to (argp_fmtstream_t stream, unsigned col)
939
int needed = col - __argp_fmtstream_point (stream);
941
__argp_fmtstream_putc (stream, ' ');
944
/* Output to STREAM either a space, or a newline if there isn't room for at
945
least ENSURE characters before the right margin. */
947
space (argp_fmtstream_t stream, size_t ensure)
949
if (__argp_fmtstream_point (stream) + ensure
950
>= __argp_fmtstream_rmargin (stream))
951
__argp_fmtstream_putc (stream, '\n');
953
__argp_fmtstream_putc (stream, ' ');
956
/* If the option REAL has an argument, we print it in using the printf
957
format REQ_FMT or OPT_FMT depending on whether it's a required or
958
optional argument. */
960
arg (const struct argp_option *real, const char *req_fmt, const char *opt_fmt,
961
const char *domain, argp_fmtstream_t stream)
965
if (real->flags & OPTION_ARG_OPTIONAL)
966
__argp_fmtstream_printf (stream, opt_fmt,
967
dgettext (domain, real->arg));
969
__argp_fmtstream_printf (stream, req_fmt,
970
dgettext (domain, real->arg));
974
/* Helper functions for hol_entry_help. */
976
/* State used during the execution of hol_help. */
977
struct hol_help_state
979
/* PREV_ENTRY should contain the previous entry printed, or 0. */
980
struct hol_entry *prev_entry;
982
/* If an entry is in a different group from the previous one, and SEP_GROUPS
983
is true, then a blank line will be printed before any output. */
986
/* True if a duplicate option argument was suppressed (only ever set if
987
UPARAMS.dup_args is false). */
988
int suppressed_dup_arg;
991
/* Some state used while printing a help entry (used to communicate with
992
helper functions). See the doc for hol_entry_help for more info, as most
993
of the fields are copied from its arguments. */
996
const struct hol_entry *entry;
997
argp_fmtstream_t stream;
998
struct hol_help_state *hhstate;
1000
/* True if nothing's been printed so far. */
1003
/* If non-zero, the state that was used to print this help. */
1004
const struct argp_state *state;
1007
/* If a user doc filter should be applied to DOC, do so. */
1009
filter_doc (const char *doc, int key, const struct argp *argp,
1010
const struct argp_state *state)
1012
if (argp->help_filter)
1013
/* We must apply a user filter to this output. */
1015
void *input = __argp_input (argp, state);
1016
return (*argp->help_filter) (key, doc, input);
1023
/* Prints STR as a header line, with the margin lines set appropiately, and
1024
notes the fact that groups should be separated with a blank line. ARGP is
1025
the argp that should dictate any user doc filtering to take place. Note
1026
that the previous wrap margin isn't restored, but the left margin is reset
1029
print_header (const char *str, const struct argp *argp,
1030
struct pentry_state *pest)
1032
const char *tstr = dgettext (argp->argp_domain, str);
1033
const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_HEADER, argp, pest->state);
1039
if (pest->hhstate->prev_entry)
1040
/* Precede with a blank line. */
1041
__argp_fmtstream_putc (pest->stream, '\n');
1042
indent_to (pest->stream, uparams.header_col);
1043
__argp_fmtstream_set_lmargin (pest->stream, uparams.header_col);
1044
__argp_fmtstream_set_wmargin (pest->stream, uparams.header_col);
1045
__argp_fmtstream_puts (pest->stream, fstr);
1046
__argp_fmtstream_set_lmargin (pest->stream, 0);
1047
__argp_fmtstream_putc (pest->stream, '\n');
1050
pest->hhstate->sep_groups = 1; /* Separate subsequent groups. */
1054
free ((char *) fstr);
1057
/* Inserts a comma if this isn't the first item on the line, and then makes
1058
sure we're at least to column COL. If this *is* the first item on a line,
1059
prints any pending whitespace/headers that should precede this line. Also
1062
comma (unsigned col, struct pentry_state *pest)
1066
const struct hol_entry *pe = pest->hhstate->prev_entry;
1067
const struct hol_cluster *cl = pest->entry->cluster;
1069
if (pest->hhstate->sep_groups && pe && pest->entry->group != pe->group)
1070
__argp_fmtstream_putc (pest->stream, '\n');
1072
if (cl && cl->header && *cl->header
1074
|| (pe->cluster != cl
1075
&& !hol_cluster_is_child (pe->cluster, cl))))
1076
/* If we're changing clusters, then this must be the start of the
1077
ENTRY's cluster unless that is an ancestor of the previous one
1078
(in which case we had just popped into a sub-cluster for a bit).
1079
If so, then print the cluster's header line. */
1081
int old_wm = __argp_fmtstream_wmargin (pest->stream);
1082
print_header (cl->header, cl->argp, pest);
1083
__argp_fmtstream_set_wmargin (pest->stream, old_wm);
1089
__argp_fmtstream_puts (pest->stream, ", ");
1091
indent_to (pest->stream, col);
1094
/* Print help for ENTRY to STREAM. */
1096
hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
1097
argp_fmtstream_t stream, struct hol_help_state *hhstate)
1100
const struct argp_option *real = entry->opt, *opt;
1101
char *so = entry->short_options;
1102
int have_long_opt = 0; /* We have any long options. */
1103
/* Saved margins. */
1104
int old_lm = __argp_fmtstream_set_lmargin (stream, 0);
1105
int old_wm = __argp_fmtstream_wmargin (stream);
1106
/* PEST is a state block holding some of our variables that we'd like to
1107
share with helper functions. */
1108
struct pentry_state pest;
1111
pest.stream = stream;
1112
pest.hhstate = hhstate;
1117
for (opt = real, num = entry->num; num > 0; opt++, num--)
1118
if (opt->name && ovisible (opt))
1124
/* First emit short options. */
1125
__argp_fmtstream_set_wmargin (stream, uparams.short_opt_col); /* For truly bizarre cases. */
1126
for (opt = real, num = entry->num; num > 0; opt++, num--)
1127
if (oshort (opt) && opt->key == *so)
1128
/* OPT has a valid (non shadowed) short option. */
1132
comma (uparams.short_opt_col, &pest);
1133
__argp_fmtstream_putc (stream, '-');
1134
__argp_fmtstream_putc (stream, *so);
1135
if (!have_long_opt || uparams.dup_args)
1136
arg (real, " %s", "[%s]", state->root_argp->argp_domain, stream);
1138
hhstate->suppressed_dup_arg = 1;
1143
/* Now, long options. */
1145
/* A `documentation' option. */
1147
__argp_fmtstream_set_wmargin (stream, uparams.doc_opt_col);
1148
for (opt = real, num = entry->num; num > 0; opt++, num--)
1149
if (opt->name && *opt->name && ovisible (opt))
1151
comma (uparams.doc_opt_col, &pest);
1152
/* Calling dgettext here isn't quite right, since sorting will
1153
have been done on the original; but documentation options
1154
should be pretty rare anyway... */
1155
__argp_fmtstream_puts (stream,
1158
dgettext (state->root_argp->argp_domain,
1163
/* A real long option. */
1165
int first_long_opt = 1;
1167
__argp_fmtstream_set_wmargin (stream, uparams.long_opt_col);
1168
for (opt = real, num = entry->num; num > 0; opt++, num--)
1169
if (opt->name && ovisible (opt))
1171
comma (uparams.long_opt_col, &pest);
1172
__argp_fmtstream_printf (stream, "--%s", opt->name);
1173
if (first_long_opt || uparams.dup_args)
1174
arg (real, "=%s", "[=%s]", state->root_argp->argp_domain,
1177
hhstate->suppressed_dup_arg = 1;
1181
/* Next, documentation strings. */
1182
__argp_fmtstream_set_lmargin (stream, 0);
1186
/* Didn't print any switches, what's up? */
1187
if (!oshort (real) && !real->name)
1188
/* This is a group header, print it nicely. */
1189
print_header (real->doc, entry->argp, &pest);
1191
/* Just a totally shadowed option or null header; print nothing. */
1192
goto cleanup; /* Just return, after cleaning up. */
1196
const char *tstr = real->doc ? dgettext (state->root_argp->argp_domain,
1198
const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
1201
unsigned int col = __argp_fmtstream_point (stream);
1203
__argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
1204
__argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
1206
if (col > (unsigned int) (uparams.opt_doc_col + 3))
1207
__argp_fmtstream_putc (stream, '\n');
1208
else if (col >= (unsigned int) uparams.opt_doc_col)
1209
__argp_fmtstream_puts (stream, " ");
1211
indent_to (stream, uparams.opt_doc_col);
1213
__argp_fmtstream_puts (stream, fstr);
1215
if (fstr && fstr != tstr)
1216
free ((char *) fstr);
1218
/* Reset the left margin. */
1219
__argp_fmtstream_set_lmargin (stream, 0);
1220
__argp_fmtstream_putc (stream, '\n');
1223
hhstate->prev_entry = entry;
1226
__argp_fmtstream_set_lmargin (stream, old_lm);
1227
__argp_fmtstream_set_wmargin (stream, old_wm);
1230
/* Output a long help message about the options in HOL to STREAM. */
1232
hol_help (struct hol *hol, const struct argp_state *state,
1233
argp_fmtstream_t stream)
1236
struct hol_entry *entry;
1237
struct hol_help_state hhstate = { 0, 0, 0 };
1239
for (entry = hol->entries, num = hol->num_entries; num > 0; entry++, num--)
1240
hol_entry_help (entry, state, stream, &hhstate);
1242
if (hhstate.suppressed_dup_arg && uparams.dup_args_note)
1244
const char *tstr = dgettext (state->root_argp->argp_domain, "\
1245
Mandatory or optional arguments to long options are also mandatory or \
1246
optional for any corresponding short options.");
1247
const char *fstr = filter_doc (tstr, ARGP_KEY_HELP_DUP_ARGS_NOTE,
1248
state ? state->root_argp : 0, state);
1251
__argp_fmtstream_putc (stream, '\n');
1252
__argp_fmtstream_puts (stream, fstr);
1253
__argp_fmtstream_putc (stream, '\n');
1255
if (fstr && fstr != tstr)
1256
free ((char *) fstr);
1260
/* Helper functions for hol_usage. */
1262
/* If OPT is a short option without an arg, append its key to the string
1263
pointer pointer to by COOKIE, and advance the pointer. */
1265
add_argless_short_opt (const struct argp_option *opt,
1266
const struct argp_option *real,
1267
const char *domain, void *cookie)
1269
char **snao_end = cookie;
1270
if (!(opt->arg || real->arg)
1271
&& !((opt->flags | real->flags) & OPTION_NO_USAGE))
1272
*(*snao_end)++ = opt->key;
1276
/* If OPT is a short option with an arg, output a usage entry for it to the
1277
stream pointed at by COOKIE. */
1279
usage_argful_short_opt (const struct argp_option *opt,
1280
const struct argp_option *real,
1281
const char *domain, void *cookie)
1283
argp_fmtstream_t stream = cookie;
1284
const char *arg = opt->arg;
1285
int flags = opt->flags | real->flags;
1290
if (arg && !(flags & OPTION_NO_USAGE))
1292
arg = dgettext (domain, arg);
1294
if (flags & OPTION_ARG_OPTIONAL)
1295
__argp_fmtstream_printf (stream, " [-%c[%s]]", opt->key, arg);
1298
/* Manually do line wrapping so that it (probably) won't
1299
get wrapped at the embedded space. */
1300
space (stream, 6 + strlen (arg));
1301
__argp_fmtstream_printf (stream, "[-%c %s]", opt->key, arg);
1308
/* Output a usage entry for the long option opt to the stream pointed at by
1311
usage_long_opt (const struct argp_option *opt,
1312
const struct argp_option *real,
1313
const char *domain, void *cookie)
1315
argp_fmtstream_t stream = cookie;
1316
const char *arg = opt->arg;
1317
int flags = opt->flags | real->flags;
1322
if (! (flags & OPTION_NO_USAGE) && !odoc (opt))
1326
arg = dgettext (domain, arg);
1327
if (flags & OPTION_ARG_OPTIONAL)
1328
__argp_fmtstream_printf (stream, " [--%s[=%s]]", opt->name, arg);
1330
__argp_fmtstream_printf (stream, " [--%s=%s]", opt->name, arg);
1333
__argp_fmtstream_printf (stream, " [--%s]", opt->name);
1339
/* Print a short usage description for the arguments in HOL to STREAM. */
1341
hol_usage (struct hol *hol, argp_fmtstream_t stream)
1343
if (hol->num_entries > 0)
1346
struct hol_entry *entry;
1347
char *short_no_arg_opts = alloca (strlen (hol->short_options) + 1);
1348
char *snao_end = short_no_arg_opts;
1350
/* First we put a list of short options without arguments. */
1351
for (entry = hol->entries, nentries = hol->num_entries
1353
; entry++, nentries--)
1354
hol_entry_short_iterate (entry, add_argless_short_opt,
1355
entry->argp->argp_domain, &snao_end);
1356
if (snao_end > short_no_arg_opts)
1359
__argp_fmtstream_printf (stream, " [-%s]", short_no_arg_opts);
1362
/* Now a list of short options *with* arguments. */
1363
for (entry = hol->entries, nentries = hol->num_entries
1365
; entry++, nentries--)
1366
hol_entry_short_iterate (entry, usage_argful_short_opt,
1367
entry->argp->argp_domain, stream);
1369
/* Finally, a list of long options (whew!). */
1370
for (entry = hol->entries, nentries = hol->num_entries
1372
; entry++, nentries--)
1373
hol_entry_long_iterate (entry, usage_long_opt,
1374
entry->argp->argp_domain, stream);
1378
/* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1379
cluster in which ARGP's entries should be clustered, or 0. */
1381
argp_hol (const struct argp *argp, struct hol_cluster *cluster)
1383
const struct argp_child *child = argp->children;
1384
struct hol *hol = make_hol (argp, cluster);
1388
struct hol_cluster *child_cluster =
1389
((child->group || child->header)
1390
/* Put CHILD->argp within its own cluster. */
1391
? hol_add_cluster (hol, child->group, child->header,
1392
child - argp->children, cluster, argp)
1393
/* Just merge it into the parent's cluster. */
1395
hol_append (hol, argp_hol (child->argp, child_cluster)) ;
1401
/* Calculate how many different levels with alternative args strings exist in
1404
argp_args_levels (const struct argp *argp)
1407
const struct argp_child *child = argp->children;
1409
if (argp->args_doc && strchr (argp->args_doc, '\n'))
1414
levels += argp_args_levels ((child++)->argp);
1419
/* Print all the non-option args documented in ARGP to STREAM. Any output is
1420
preceded by a space. LEVELS is a pointer to a byte vector the length
1421
returned by argp_args_levels; it should be initialized to zero, and
1422
updated by this routine for the next call if ADVANCE is true. True is
1423
returned as long as there are more patterns to output. */
1425
argp_args_usage (const struct argp *argp, const struct argp_state *state,
1426
char **levels, int advance, argp_fmtstream_t stream)
1428
char *our_level = *levels;
1430
const struct argp_child *child = argp->children;
1431
const char *tdoc = dgettext (argp->argp_domain, argp->args_doc), *nl = 0;
1432
const char *fdoc = filter_doc (tdoc, ARGP_KEY_HELP_ARGS_DOC, argp, state);
1436
const char *cp = fdoc;
1437
nl = __strchrnul (cp, '\n');
1439
/* This is a `multi-level' args doc; advance to the correct position
1440
as determined by our state in LEVELS, and update LEVELS. */
1444
for (i = 0; i < *our_level; i++)
1445
cp = nl + 1, nl = __strchrnul (cp, '\n');
1449
/* Manually do line wrapping so that it (probably) won't get wrapped at
1450
any embedded spaces. */
1451
space (stream, 1 + nl - cp);
1453
__argp_fmtstream_write (stream, cp, nl - cp);
1455
if (fdoc && fdoc != tdoc)
1456
free ((char *)fdoc); /* Free user's modified doc string. */
1460
advance = !argp_args_usage ((child++)->argp, state, levels, advance, stream);
1462
if (advance && multiple)
1464
/* Need to increment our level. */
1466
/* There's more we can do here. */
1469
advance = 0; /* Our parent shouldn't advance also. */
1471
else if (*our_level > 0)
1472
/* We had multiple levels, but used them up; reset to zero. */
1479
/* Print the documentation for ARGP to STREAM; if POST is false, then
1480
everything preceeding a `\v' character in the documentation strings (or
1481
the whole string, for those with none) is printed, otherwise, everything
1482
following the `\v' character (nothing for strings without). Each separate
1483
bit of documentation is separated a blank line, and if PRE_BLANK is true,
1484
then the first is as well. If FIRST_ONLY is true, only the first
1485
occurrence is output. Returns true if anything was output. */
1487
argp_doc (const struct argp *argp, const struct argp_state *state,
1488
int post, int pre_blank, int first_only,
1489
argp_fmtstream_t stream)
1492
const char *inp_text;
1493
size_t inp_text_len = 0;
1494
const char *trans_text;
1497
const struct argp_child *child = argp->children;
1501
char *vt = strchr (argp->doc, '\v');
1508
inp_text_len = vt - argp->doc;
1509
inp_text = __strndup (argp->doc, inp_text_len);
1513
inp_text = post ? 0 : argp->doc;
1514
trans_text = inp_text ? dgettext (argp->argp_domain, inp_text) : NULL;
1517
trans_text = inp_text = 0;
1519
if (argp->help_filter)
1520
/* We have to filter the doc strings. */
1522
input = __argp_input (argp, state);
1524
(*argp->help_filter) (post
1525
? ARGP_KEY_HELP_POST_DOC
1526
: ARGP_KEY_HELP_PRE_DOC,
1530
text = (const char *) trans_text;
1535
__argp_fmtstream_putc (stream, '\n');
1537
__argp_fmtstream_puts (stream, text);
1539
if (__argp_fmtstream_point (stream) > __argp_fmtstream_lmargin (stream))
1540
__argp_fmtstream_putc (stream, '\n');
1545
if (text && text != trans_text)
1546
free ((char *) text); /* Free TEXT returned from the help filter. */
1548
if (inp_text && inp_text_len)
1549
free ((char *) inp_text); /* We copied INP_TEXT, so free it now. */
1551
if (post && argp->help_filter)
1552
/* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1554
text = (*argp->help_filter) (ARGP_KEY_HELP_EXTRA, 0, input);
1557
if (anything || pre_blank)
1558
__argp_fmtstream_putc (stream, '\n');
1559
__argp_fmtstream_puts (stream, text);
1560
free ((char *) text);
1561
if (__argp_fmtstream_point (stream)
1562
> __argp_fmtstream_lmargin (stream))
1563
__argp_fmtstream_putc (stream, '\n');
1569
while (child->argp && !(first_only && anything))
1571
argp_doc ((child++)->argp, state,
1572
post, anything || pre_blank, first_only,
1578
/* Output a usage message for ARGP to STREAM. If called from
1579
argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1580
set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1583
_help (const struct argp *argp, const struct argp_state *state, FILE *stream,
1584
unsigned flags, char *name)
1586
int anything = 0; /* Whether we've output anything. */
1587
struct hol *hol = 0;
1588
argp_fmtstream_t fs;
1593
#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1594
__flockfile (stream);
1597
if (! uparams.valid)
1598
fill_in_uparams (state);
1600
fs = __argp_make_fmtstream (stream, 0, uparams.rmargin, 0);
1603
#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1604
__funlockfile (stream);
1609
if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG))
1611
hol = argp_hol (argp, 0);
1613
/* If present, these options always come last. */
1614
hol_set_group (hol, "help", -1);
1615
hol_set_group (hol, "version", -1);
1620
if (flags & (ARGP_HELP_USAGE | ARGP_HELP_SHORT_USAGE))
1621
/* Print a short `Usage:' message. */
1623
int first_pattern = 1, more_patterns;
1624
size_t num_pattern_levels = argp_args_levels (argp);
1625
char *pattern_levels = alloca (num_pattern_levels);
1627
memset (pattern_levels, 0, num_pattern_levels);
1632
int old_wm = __argp_fmtstream_set_wmargin (fs, uparams.usage_indent);
1633
char *levels = pattern_levels;
1636
__argp_fmtstream_printf (fs, "%s %s",
1637
dgettext (argp->argp_domain, "Usage:"),
1640
__argp_fmtstream_printf (fs, "%s %s",
1641
dgettext (argp->argp_domain, " or: "),
1644
/* We set the lmargin as well as the wmargin, because hol_usage
1645
manually wraps options with newline to avoid annoying breaks. */
1646
old_lm = __argp_fmtstream_set_lmargin (fs, uparams.usage_indent);
1648
if (flags & ARGP_HELP_SHORT_USAGE)
1649
/* Just show where the options go. */
1651
if (hol->num_entries > 0)
1652
__argp_fmtstream_puts (fs, dgettext (argp->argp_domain,
1656
/* Actually print the options. */
1658
hol_usage (hol, fs);
1659
flags |= ARGP_HELP_SHORT_USAGE; /* But only do so once. */
1662
more_patterns = argp_args_usage (argp, state, &levels, 1, fs);
1664
__argp_fmtstream_set_wmargin (fs, old_wm);
1665
__argp_fmtstream_set_lmargin (fs, old_lm);
1667
__argp_fmtstream_putc (fs, '\n');
1672
while (more_patterns);
1675
if (flags & ARGP_HELP_PRE_DOC)
1676
anything |= argp_doc (argp, state, 0, 0, 1, fs);
1678
if (flags & ARGP_HELP_SEE)
1680
__argp_fmtstream_printf (fs, dgettext (argp->argp_domain, "\
1681
Try `%s --help' or `%s --usage' for more information.\n"),
1686
if (flags & ARGP_HELP_LONG)
1687
/* Print a long, detailed help message. */
1689
/* Print info about all the options. */
1690
if (hol->num_entries > 0)
1693
__argp_fmtstream_putc (fs, '\n');
1694
hol_help (hol, state, fs);
1699
if (flags & ARGP_HELP_POST_DOC)
1700
/* Print any documentation strings at the end. */
1701
anything |= argp_doc (argp, state, 1, anything, 0, fs);
1703
if ((flags & ARGP_HELP_BUG_ADDR) && argp_program_bug_address)
1706
__argp_fmtstream_putc (fs, '\n');
1707
__argp_fmtstream_printf (fs, dgettext (argp->argp_domain,
1708
"Report bugs to %s.\n"),
1709
argp_program_bug_address);
1713
#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1714
__funlockfile (stream);
1720
__argp_fmtstream_free (fs);
1723
/* Output a usage message for ARGP to STREAM. FLAGS are from the set
1724
ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1725
void __argp_help (const struct argp *argp, FILE *stream,
1726
unsigned flags, char *name)
1728
struct argp_state state;
1729
memset (&state, 0, sizeof state);
1730
state.root_argp = argp;
1731
_help (argp, &state, stream, flags, name);
1734
weak_alias (__argp_help, argp_help)
1737
#if ! (defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME)
1739
__argp_short_program_name (void)
1741
# if HAVE_DECL_PROGRAM_INVOCATION_NAME
1742
return __argp_base_name (program_invocation_name);
1744
/* FIXME: What now? Miles suggests that it is better to use NULL,
1745
but currently the value is passed on directly to fputs_unlocked,
1746
so that requires more changes. */
1748
# warning No reasonable value to return
1749
# endif /* __GNUC__ */
1755
/* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1756
from the set ARGP_HELP_*. */
1758
__argp_state_help (const struct argp_state *state, FILE *stream, unsigned flags)
1760
if ((!state || ! (state->flags & ARGP_NO_ERRS)) && stream)
1762
if (state && (state->flags & ARGP_LONG_ONLY))
1763
flags |= ARGP_HELP_LONG_ONLY;
1765
_help (state ? state->root_argp : 0, state, stream, flags,
1766
state ? state->name : __argp_short_program_name ());
1768
if (!state || ! (state->flags & ARGP_NO_EXIT))
1770
if (flags & ARGP_HELP_EXIT_ERR)
1771
exit (argp_err_exit_status);
1772
if (flags & ARGP_HELP_EXIT_OK)
1778
weak_alias (__argp_state_help, argp_state_help)
1781
/* If appropriate, print the printf string FMT and following args, preceded
1782
by the program name and `:', to stderr, and followed by a `Try ... --help'
1783
message, then exit (1). */
1785
__argp_error (const struct argp_state *state, const char *fmt, ...)
1787
if (!state || !(state->flags & ARGP_NO_ERRS))
1789
FILE *stream = state ? state->err_stream : stderr;
1795
#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1796
__flockfile (stream);
1802
if (_IO_fwide (stream, 0) > 0)
1806
if (__asprintf (&buf, fmt, ap) < 0)
1809
__fwprintf (stream, L"%s: %s\n",
1810
state ? state->name : __argp_short_program_name (),
1818
fputs_unlocked (state
1819
? state->name : __argp_short_program_name (),
1821
putc_unlocked (':', stream);
1822
putc_unlocked (' ', stream);
1824
vfprintf (stream, fmt, ap);
1826
putc_unlocked ('\n', stream);
1829
__argp_state_help (state, stream, ARGP_HELP_STD_ERR);
1833
#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1834
__funlockfile (stream);
1840
weak_alias (__argp_error, argp_error)
1843
/* Similar to the standard gnu error-reporting function error(), but will
1844
respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1845
to STATE->err_stream. This is useful for argument parsing code that is
1846
shared between program startup (when exiting is desired) and runtime
1847
option parsing (when typically an error code is returned instead). The
1848
difference between this function and argp_error is that the latter is for
1849
*parsing errors*, and the former is for other problems that occur during
1850
parsing but don't reflect a (syntactic) problem with the input. */
1852
__argp_failure (const struct argp_state *state, int status, int errnum,
1853
const char *fmt, ...)
1855
if (!state || !(state->flags & ARGP_NO_ERRS))
1857
FILE *stream = state ? state->err_stream : stderr;
1861
#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1862
__flockfile (stream);
1866
if (_IO_fwide (stream, 0) > 0)
1867
__fwprintf (stream, L"%s",
1868
state ? state->name : __argp_short_program_name ());
1871
fputs_unlocked (state
1872
? state->name : __argp_short_program_name (),
1881
if (_IO_fwide (stream, 0) > 0)
1885
if (__asprintf (&buf, fmt, ap) < 0)
1888
__fwprintf (stream, L": %s", buf);
1895
putc_unlocked (':', stream);
1896
putc_unlocked (' ', stream);
1898
vfprintf (stream, fmt, ap);
1909
if (_IO_fwide (stream, 0) > 0)
1910
__fwprintf (stream, L": %s",
1911
__strerror_r (errnum, buf, sizeof (buf)));
1915
char const *s = NULL;
1916
putc_unlocked (':', stream);
1917
putc_unlocked (' ', stream);
1918
#if _LIBC || (HAVE_DECL_STRERROR_R && STRERROR_R_CHAR_P)
1919
s = __strerror_r (errnum, buf, sizeof buf);
1920
#elif HAVE_DECL_STRERROR_R
1921
if (__strerror_r (errnum, buf, sizeof buf) == 0)
1925
if (! s && ! (s = strerror (errnum)))
1926
s = dgettext (state->root_argp->argp_domain,
1927
"Unknown system error");
1934
if (_IO_fwide (stream, 0) > 0)
1935
putwc_unlocked (L'\n', stream);
1938
putc_unlocked ('\n', stream);
1940
#if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1941
__funlockfile (stream);
1944
if (status && (!state || !(state->flags & ARGP_NO_EXIT)))
1950
weak_alias (__argp_failure, argp_failure)
added
removed
grub-core/gnulib/argp-help.c
