1 /* Hierarchial argument parsing help output
2 Copyright (C) 1995-2000, 2001 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 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 The GNU C Library 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 GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
22 # define _GNU_SOURCE 1
31 # define alloca __builtin_alloca
32 # define HAVE_ALLOCA 1
34 # if defined HAVE_ALLOCA_H || defined _LIBC
60 /* This is for other GNU distributions with internationalized messages. */
61 # if defined HAVE_LIBINTL_H || defined _LIBC
65 # define dgettext(domain, msgid) __dcgettext (domain, msgid, LC_MESSAGES)
68 # define dgettext(domain, msgid) (msgid)
73 #include "argp-fmtstream.h"
74 #include "argp-namefrob.h"
76 /* User-selectable (using an environment variable) formatting parameters.
78 These may be specified in an environment variable called `ARGP_HELP_FMT',
79 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
80 Where VALn must be a positive integer. The list of variables is in the
81 UPARAM_NAMES vector, below. */
83 /* Default parameters. */
84 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
85 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
86 #define SHORT_OPT_COL 2 /* column in which short options start */
87 #define LONG_OPT_COL 6 /* column in which long options start */
88 #define DOC_OPT_COL 2 /* column in which doc options start */
89 #define OPT_DOC_COL 29 /* column in which option text starts */
90 #define HEADER_COL 1 /* column in which group headers are printed */
91 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
92 #define RMARGIN 79 /* right margin used for wrapping */
94 /* User-selectable (using an environment variable) formatting parameters.
95 They must all be of type `int' for the parsing code to work. */
98 /* If true, arguments for an option are shown with both short and long
99 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
100 If false, then if an option has both, the argument is only shown with
101 the long one, e.g., `-x, --longx=ARG', and a message indicating that
102 this really means both is printed below the options. */
105 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
106 been suppressed, an explanatory message should be printed. */
109 /* Various output columns. */
118 int valid
; /* True when the values in here are valid. */
121 /* This is a global variable, as user options are only ever read once. */
122 static struct uparams uparams
= {
123 DUP_ARGS
, DUP_ARGS_NOTE
,
124 SHORT_OPT_COL
, LONG_OPT_COL
, DOC_OPT_COL
, OPT_DOC_COL
, HEADER_COL
,
125 USAGE_INDENT
, RMARGIN
,
129 /* A particular uparam, and what the user name is. */
132 const char *name
; /* User name. */
133 int is_bool
; /* Whether it's `boolean'. */
134 size_t uparams_offs
; /* Location of the (int) field in UPARAMS. */
137 /* The name-field mappings we know about. */
138 static const struct uparam_name uparam_names
[] =
140 { "dup-args", 1, offsetof (struct uparams
, dup_args
) },
141 { "dup-args-note", 1, offsetof (struct uparams
, dup_args_note
) },
142 { "short-opt-col", 0, offsetof (struct uparams
, short_opt_col
) },
143 { "long-opt-col", 0, offsetof (struct uparams
, long_opt_col
) },
144 { "doc-opt-col", 0, offsetof (struct uparams
, doc_opt_col
) },
145 { "opt-doc-col", 0, offsetof (struct uparams
, opt_doc_col
) },
146 { "header-col", 0, offsetof (struct uparams
, header_col
) },
147 { "usage-indent", 0, offsetof (struct uparams
, usage_indent
) },
148 { "rmargin", 0, offsetof (struct uparams
, rmargin
) },
152 /* Read user options from the environment, and fill in UPARAMS appropiately. */
154 fill_in_uparams (const struct argp_state
*state
)
156 const char *var
= getenv ("ARGP_HELP_FMT");
158 #define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
169 const struct uparam_name
*un
;
170 int unspec
= 0, val
= 0;
171 const char *arg
= var
;
173 while (isalnum (*arg
) || *arg
== '-' || *arg
== '_')
179 if (*arg
== '\0' || *arg
== ',')
181 else if (*arg
== '=')
189 if (var
[0] == 'n' && var
[1] == 'o' && var
[2] == '-')
198 else if (isdigit (*arg
))
201 while (isdigit (*arg
))
206 for (un
= uparam_names
; un
->name
; un
++)
207 if (strlen (un
->name
) == var_len
208 && strncmp (var
, un
->name
, var_len
) == 0)
210 if (unspec
&& !un
->is_bool
)
211 __argp_failure (state
, 0, 0,
212 dgettext (state
->root_argp
->argp_domain
, "\
213 %.*s: ARGP_HELP_FMT parameter requires a value"),
216 *(int *)((char *)&uparams
+ un
->uparams_offs
) = val
;
220 __argp_failure (state
, 0, 0,
221 dgettext (state
->root_argp
->argp_domain
, "\
222 %.*s: Unknown ARGP_HELP_FMT parameter"),
231 __argp_failure (state
, 0, 0,
232 dgettext (state
->root_argp
->argp_domain
,
233 "Garbage in ARGP_HELP_FMT: %s"), var
);
239 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
240 whether OPT is displayed or used in sorting, not option shadowing. */
241 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
243 /* Returns true if OPT is an alias for an earlier option. */
244 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
246 /* Returns true if OPT is an documentation-only entry. */
247 #define odoc(opt) ((opt)->flags & OPTION_DOC)
249 /* Returns true if OPT is the end-of-list marker for a list of options. */
250 #define oend(opt) __option_is_end (opt)
252 /* Returns true if OPT has a short option. */
253 #define oshort(opt) __option_is_short (opt)
256 The help format for a particular option is like:
258 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
260 Where ARG will be omitted if there's no argument, for this option, or
261 will be surrounded by "[" and "]" appropiately if the argument is
262 optional. The documentation string is word-wrapped appropiately, and if
263 the list of options is long enough, it will be started on a separate line.
264 If there are no short options for a given option, the first long option is
265 indented slighly in a way that's supposed to make most long options appear
266 to be in a separate column.
268 For example, the following output (from ps):
270 -p PID, --pid=PID List the process PID
271 --pgrp=PGRP List processes in the process group PGRP
272 -P, -x, --no-parent Include processes without parents
273 -Q, --all-fields Don't elide unusable fields (normally if there's
274 some reason ps can't print a field for any
275 process, it's removed from the output entirely)
276 -r, --reverse, --gratuitously-long-reverse-option
277 Reverse the order of any sort
278 --session[=SID] Add the processes from the session SID (which
279 defaults to the sid of the current process)
281 Here are some more options:
282 -f ZOT, --foonly=ZOT Glork a foonly
283 -z, --zaza Snit a zar
285 -?, --help Give this help list
286 --usage Give a short usage message
287 -V, --version Print program version
289 The struct argp_option array for the above could look like:
292 {"pid", 'p', "PID", 0, "List the process PID"},
293 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
294 {"no-parent", 'P', 0, 0, "Include processes without parents"},
295 {0, 'x', 0, OPTION_ALIAS},
296 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
297 " if there's some reason ps can't"
298 " print a field for any process, it's"
299 " removed from the output entirely)" },
300 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
301 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
302 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
303 "Add the processes from the session"
304 " SID (which defaults to the sid of"
305 " the current process)" },
307 {0,0,0,0, "Here are some more options:"},
308 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
309 {"zaza", 'z', 0, 0, "Snit a zar"},
314 Note that the last three options are automatically supplied by argp_parse,
315 unless you tell it not to with ARGP_NO_HELP.
319 /* Returns true if CH occurs between BEG and END. */
321 find_char (char ch
, char *beg
, char *end
)
331 struct hol_cluster
; /* fwd decl */
336 const struct argp_option
*opt
;
337 /* Number of options (including aliases). */
340 /* A pointers into the HOL's short_options field, to the first short option
341 letter for this entry. The order of the characters following this point
342 corresponds to the order of options pointed to by OPT, and there are at
343 most NUM. A short option recorded in a option following OPT is only
344 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
345 probably been shadowed by some other entry). */
348 /* Entries are sorted by their group first, in the order:
349 1, 2, ..., n, 0, -m, ..., -2, -1
350 and then alphabetically within each group. The default is 0. */
353 /* The cluster of options this entry belongs to, or 0 if none. */
354 struct hol_cluster
*cluster
;
356 /* The argp from which this option came. */
357 const struct argp
*argp
;
360 /* A cluster of entries to reflect the argp tree structure. */
363 /* A descriptive header printed before options in this cluster. */
366 /* Used to order clusters within the same group with the same parent,
367 according to the order in which they occurred in the parent argp's child
371 /* How to sort this cluster with respect to options and other clusters at the
372 same depth (clusters always follow options in the same group). */
375 /* The cluster to which this cluster belongs, or 0 if it's at the base
377 struct hol_cluster
*parent
;
379 /* The argp from which this cluster is (eventually) derived. */
380 const struct argp
*argp
;
382 /* The distance this cluster is from the root. */
385 /* Clusters in a given hol are kept in a linked list, to make freeing them
387 struct hol_cluster
*next
;
390 /* A list of options for help. */
393 /* An array of hol_entry's. */
394 struct hol_entry
*entries
;
395 /* The number of entries in this hol. If this field is zero, the others
397 unsigned num_entries
;
399 /* A string containing all short options in this HOL. Each entry contains
400 pointers into this string, so the order can't be messed with blindly. */
403 /* Clusters of entries in this hol. */
404 struct hol_cluster
*clusters
;
407 /* Create a struct hol from the options in ARGP. CLUSTER is the
408 hol_cluster in which these entries occur, or 0, if at the root. */
410 make_hol (const struct argp
*argp
, struct hol_cluster
*cluster
)
413 const struct argp_option
*o
;
414 const struct argp_option
*opts
= argp
->options
;
415 struct hol_entry
*entry
;
416 unsigned num_short_options
= 0;
417 struct hol
*hol
= malloc (sizeof (struct hol
));
421 hol
->num_entries
= 0;
428 /* The first option must not be an alias. */
429 assert (! oalias (opts
));
431 /* Calculate the space needed. */
432 for (o
= opts
; ! oend (o
); o
++)
437 num_short_options
++; /* This is an upper bound. */
440 hol
->entries
= malloc (sizeof (struct hol_entry
) * hol
->num_entries
);
441 hol
->short_options
= malloc (num_short_options
+ 1);
443 assert (hol
->entries
&& hol
->short_options
);
445 /* Fill in the entries. */
446 so
= hol
->short_options
;
447 for (o
= opts
, entry
= hol
->entries
; ! oend (o
); entry
++)
451 entry
->short_options
= so
;
452 entry
->group
= cur_group
=
455 : ((!o
->name
&& !o
->key
)
458 entry
->cluster
= cluster
;
464 if (oshort (o
) && ! find_char (o
->key
, hol
->short_options
, so
))
465 /* O has a valid short option which hasn't already been used.*/
469 while (! oend (o
) && oalias (o
));
471 *so
= '\0'; /* null terminated so we can find the length */
477 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
478 associated argp child list entry), INDEX, and PARENT, and return a pointer
479 to it. ARGP is the argp that this cluster results from. */
480 static struct hol_cluster
*
481 hol_add_cluster (struct hol
*hol
, int group
, const char *header
, int index
,
482 struct hol_cluster
*parent
, const struct argp
*argp
)
484 struct hol_cluster
*cl
= malloc (sizeof (struct hol_cluster
));
493 cl
->depth
= parent
? parent
->depth
+ 1 : 0;
495 cl
->next
= hol
->clusters
;
501 /* Free HOL and any resources it uses. */
503 hol_free (struct hol
*hol
)
505 struct hol_cluster
*cl
= hol
->clusters
;
509 struct hol_cluster
*next
= cl
->next
;
514 if (hol
->num_entries
> 0)
517 free (hol
->short_options
);
524 hol_entry_short_iterate (const struct hol_entry
*entry
,
525 int (*func
)(const struct argp_option
*opt
,
526 const struct argp_option
*real
,
527 const char *domain
, void *cookie
),
528 const char *domain
, void *cookie
)
532 const struct argp_option
*opt
, *real
= entry
->opt
;
533 char *so
= entry
->short_options
;
535 for (opt
= real
, nopts
= entry
->num
; nopts
> 0 && !val
; opt
++, nopts
--)
536 if (oshort (opt
) && *so
== opt
->key
)
541 val
= (*func
)(opt
, real
, domain
, cookie
);
549 hol_entry_long_iterate (const struct hol_entry
*entry
,
550 int (*func
)(const struct argp_option
*opt
,
551 const struct argp_option
*real
,
552 const char *domain
, void *cookie
),
553 const char *domain
, void *cookie
)
557 const struct argp_option
*opt
, *real
= entry
->opt
;
559 for (opt
= real
, nopts
= entry
->num
; nopts
> 0 && !val
; opt
++, nopts
--)
565 val
= (*func
)(opt
, real
, domain
, cookie
);
571 /* Iterator that returns true for the first short option. */
573 until_short (const struct argp_option
*opt
, const struct argp_option
*real
,
574 const char *domain
, void *cookie
)
576 return oshort (opt
) ? opt
->key
: 0;
579 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
581 hol_entry_first_short (const struct hol_entry
*entry
)
583 return hol_entry_short_iterate (entry
, until_short
,
584 entry
->argp
->argp_domain
, 0);
587 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
589 hol_entry_first_long (const struct hol_entry
*entry
)
591 const struct argp_option
*opt
;
593 for (opt
= entry
->opt
, num
= entry
->num
; num
> 0; opt
++, num
--)
594 if (opt
->name
&& ovisible (opt
))
599 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
601 static struct hol_entry
*
602 hol_find_entry (struct hol
*hol
, const char *name
)
604 struct hol_entry
*entry
= hol
->entries
;
605 unsigned num_entries
= hol
->num_entries
;
607 while (num_entries
-- > 0)
609 const struct argp_option
*opt
= entry
->opt
;
610 unsigned num_opts
= entry
->num
;
612 while (num_opts
-- > 0)
613 if (opt
->name
&& ovisible (opt
) && strcmp (opt
->name
, name
) == 0)
624 /* If an entry with the long option NAME occurs in HOL, set it's special
625 sort position to GROUP. */
627 hol_set_group (struct hol
*hol
, const char *name
, int group
)
629 struct hol_entry
*entry
= hol_find_entry (hol
, name
);
631 entry
->group
= group
;
634 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
635 EQ is what to return if GROUP1 and GROUP2 are the same. */
637 group_cmp (int group1
, int group2
, int eq
)
639 if (group1
== group2
)
641 else if ((group1
< 0 && group2
< 0) || (group1
>= 0 && group2
>= 0))
642 return group1
- group2
;
644 return group2
- group1
;
647 /* Compare clusters CL1 & CL2 by the order that they should appear in
650 hol_cluster_cmp (const struct hol_cluster
*cl1
, const struct hol_cluster
*cl2
)
652 /* If one cluster is deeper than the other, use its ancestor at the same
653 level, so that finding the common ancestor is straightforward. */
654 while (cl1
->depth
< cl2
->depth
)
656 while (cl2
->depth
< cl1
->depth
)
659 /* Now reduce both clusters to their ancestors at the point where both have
660 a common parent; these can be directly compared. */
661 while (cl1
->parent
!= cl2
->parent
)
662 cl1
= cl1
->parent
, cl2
= cl2
->parent
;
664 return group_cmp (cl1
->group
, cl2
->group
, cl2
->index
- cl1
->index
);
667 /* Return the ancestor of CL that's just below the root (i.e., has a parent
669 static struct hol_cluster
*
670 hol_cluster_base (struct hol_cluster
*cl
)
677 /* Return true if CL1 is a child of CL2. */
679 hol_cluster_is_child (const struct hol_cluster
*cl1
,
680 const struct hol_cluster
*cl2
)
682 while (cl1
&& cl1
!= cl2
)
687 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
688 that should be used for comparisons, and returns true iff it should be
689 treated as a non-option. */
691 canon_doc_option (const char **name
)
694 /* Skip initial whitespace. */
695 while (isspace (**name
))
697 /* Decide whether this looks like an option (leading `-') or not. */
698 non_opt
= (**name
!= '-');
699 /* Skip until part of name used for sorting. */
700 while (**name
&& !isalnum (**name
))
705 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
708 hol_entry_cmp (const struct hol_entry
*entry1
,
709 const struct hol_entry
*entry2
)
711 /* The group numbers by which the entries should be ordered; if either is
712 in a cluster, then this is just the group within the cluster. */
713 int group1
= entry1
->group
, group2
= entry2
->group
;
715 if (entry1
->cluster
!= entry2
->cluster
)
717 /* The entries are not within the same cluster, so we can't compare them
718 directly, we have to use the appropiate clustering level too. */
719 if (! entry1
->cluster
)
720 /* ENTRY1 is at the `base level', not in a cluster, so we have to
721 compare it's group number with that of the base cluster in which
722 ENTRY2 resides. Note that if they're in the same group, the
723 clustered option always comes laster. */
724 return group_cmp (group1
, hol_cluster_base (entry2
->cluster
)->group
, -1);
725 else if (! entry2
->cluster
)
726 /* Likewise, but ENTRY2's not in a cluster. */
727 return group_cmp (hol_cluster_base (entry1
->cluster
)->group
, group2
, 1);
729 /* Both entries are in clusters, we can just compare the clusters. */
730 return hol_cluster_cmp (entry1
->cluster
, entry2
->cluster
);
732 else if (group1
== group2
)
733 /* The entries are both in the same cluster and group, so compare them
736 int short1
= hol_entry_first_short (entry1
);
737 int short2
= hol_entry_first_short (entry2
);
738 int doc1
= odoc (entry1
->opt
);
739 int doc2
= odoc (entry2
->opt
);
740 const char *long1
= hol_entry_first_long (entry1
);
741 const char *long2
= hol_entry_first_long (entry2
);
744 doc1
= canon_doc_option (&long1
);
746 doc2
= canon_doc_option (&long2
);
749 /* `documentation' options always follow normal options (or
750 documentation options that *look* like normal options). */
752 else if (!short1
&& !short2
&& long1
&& long2
)
753 /* Only long options. */
754 return __strcasecmp (long1
, long2
);
756 /* Compare short/short, long/short, short/long, using the first
757 character of long options. Entries without *any* valid
758 options (such as options with OPTION_HIDDEN set) will be put
759 first, but as they're not displayed, it doesn't matter where
762 char first1
= short1
? short1
: long1
? *long1
: 0;
763 char first2
= short2
? short2
: long2
? *long2
: 0;
765 int lower_cmp
= _tolower (first1
) - _tolower (first2
);
767 int lower_cmp
= tolower (first1
) - tolower (first2
);
769 /* Compare ignoring case, except when the options are both the
770 same letter, in which case lower-case always comes first. */
771 return lower_cmp
? lower_cmp
: first2
- first1
;
775 /* Within the same cluster, but not the same group, so just compare
777 return group_cmp (group1
, group2
, 0);
780 /* Version of hol_entry_cmp with correct signature for qsort. */
782 hol_entry_qcmp (const void *entry1_v
, const void *entry2_v
)
784 return hol_entry_cmp (entry1_v
, entry2_v
);
787 /* Sort HOL by group and alphabetically by option name (with short options
788 taking precedence over long). Since the sorting is for display purposes
789 only, the shadowing of options isn't effected. */
791 hol_sort (struct hol
*hol
)
793 if (hol
->num_entries
> 0)
794 qsort (hol
->entries
, hol
->num_entries
, sizeof (struct hol_entry
),
798 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
799 any in MORE with the same name. */
801 hol_append (struct hol
*hol
, struct hol
*more
)
803 struct hol_cluster
**cl_end
= &hol
->clusters
;
805 /* Steal MORE's cluster list, and add it to the end of HOL's. */
807 cl_end
= &(*cl_end
)->next
;
808 *cl_end
= more
->clusters
;
812 if (more
->num_entries
> 0)
814 if (hol
->num_entries
== 0)
816 hol
->num_entries
= more
->num_entries
;
817 hol
->entries
= more
->entries
;
818 hol
->short_options
= more
->short_options
;
819 more
->num_entries
= 0; /* Mark MORE's fields as invalid. */
822 /* Append the entries in MORE to those in HOL, taking care to only add
823 non-shadowed SHORT_OPTIONS values. */
828 unsigned num_entries
= hol
->num_entries
+ more
->num_entries
;
829 struct hol_entry
*entries
=
830 malloc (num_entries
* sizeof (struct hol_entry
));
831 unsigned hol_so_len
= strlen (hol
->short_options
);
832 char *short_options
=
833 malloc (hol_so_len
+ strlen (more
->short_options
) + 1);
835 __mempcpy (__mempcpy (entries
, hol
->entries
,
836 hol
->num_entries
* sizeof (struct hol_entry
)),
838 more
->num_entries
* sizeof (struct hol_entry
));
840 __mempcpy (short_options
, hol
->short_options
, hol_so_len
);
842 /* Fix up the short options pointers from HOL. */
843 for (e
= entries
, left
= hol
->num_entries
; left
> 0; e
++, left
--)
844 e
->short_options
+= (short_options
- hol
->short_options
);
846 /* Now add the short options from MORE, fixing up its entries
848 so
= short_options
+ hol_so_len
;
849 more_so
= more
->short_options
;
850 for (left
= more
->num_entries
; left
> 0; e
++, left
--)
853 const struct argp_option
*opt
;
855 e
->short_options
= so
;
857 for (opts_left
= e
->num
, opt
= e
->opt
; opts_left
; opt
++, opts_left
--)
860 if (oshort (opt
) && ch
== opt
->key
)
861 /* The next short option in MORE_SO, CH, is from OPT. */
863 if (! find_char (ch
, short_options
,
864 short_options
+ hol_so_len
))
865 /* The short option CH isn't shadowed by HOL's options,
866 so add it to the sum. */
876 free (hol
->short_options
);
878 hol
->entries
= entries
;
879 hol
->num_entries
= num_entries
;
880 hol
->short_options
= short_options
;
887 /* Inserts enough spaces to make sure STREAM is at column COL. */
889 indent_to (argp_fmtstream_t stream
, unsigned col
)
891 int needed
= col
- __argp_fmtstream_point (stream
);
893 __argp_fmtstream_putc (stream
, ' ');
896 /* Output to STREAM either a space, or a newline if there isn't room for at
897 least ENSURE characters before the right margin. */
899 space (argp_fmtstream_t stream
, size_t ensure
)
901 if (__argp_fmtstream_point (stream
) + ensure
902 >= __argp_fmtstream_rmargin (stream
))
903 __argp_fmtstream_putc (stream
, '\n');
905 __argp_fmtstream_putc (stream
, ' ');
908 /* If the option REAL has an argument, we print it in using the printf
909 format REQ_FMT or OPT_FMT depending on whether it's a required or
910 optional argument. */
912 arg (const struct argp_option
*real
, const char *req_fmt
, const char *opt_fmt
,
913 const char *domain
, argp_fmtstream_t stream
)
917 if (real
->flags
& OPTION_ARG_OPTIONAL
)
918 __argp_fmtstream_printf (stream
, opt_fmt
,
919 dgettext (domain
, real
->arg
));
921 __argp_fmtstream_printf (stream
, req_fmt
,
922 dgettext (domain
, real
->arg
));
926 /* Helper functions for hol_entry_help. */
928 /* State used during the execution of hol_help. */
929 struct hol_help_state
931 /* PREV_ENTRY should contain the previous entry printed, or 0. */
932 struct hol_entry
*prev_entry
;
934 /* If an entry is in a different group from the previous one, and SEP_GROUPS
935 is true, then a blank line will be printed before any output. */
938 /* True if a duplicate option argument was suppressed (only ever set if
939 UPARAMS.dup_args is false). */
940 int suppressed_dup_arg
;
943 /* Some state used while printing a help entry (used to communicate with
944 helper functions). See the doc for hol_entry_help for more info, as most
945 of the fields are copied from its arguments. */
948 const struct hol_entry
*entry
;
949 argp_fmtstream_t stream
;
950 struct hol_help_state
*hhstate
;
952 /* True if nothing's been printed so far. */
955 /* If non-zero, the state that was used to print this help. */
956 const struct argp_state
*state
;
959 /* If a user doc filter should be applied to DOC, do so. */
961 filter_doc (const char *doc
, int key
, const struct argp
*argp
,
962 const struct argp_state
*state
)
964 if (argp
->help_filter
)
965 /* We must apply a user filter to this output. */
967 void *input
= __argp_input (argp
, state
);
968 return (*argp
->help_filter
) (key
, doc
, input
);
975 /* Prints STR as a header line, with the margin lines set appropiately, and
976 notes the fact that groups should be separated with a blank line. ARGP is
977 the argp that should dictate any user doc filtering to take place. Note
978 that the previous wrap margin isn't restored, but the left margin is reset
981 print_header (const char *str
, const struct argp
*argp
,
982 struct pentry_state
*pest
)
984 const char *tstr
= dgettext (argp
->argp_domain
, str
);
985 const char *fstr
= filter_doc (tstr
, ARGP_KEY_HELP_HEADER
, argp
, pest
->state
);
991 if (pest
->hhstate
->prev_entry
)
992 /* Precede with a blank line. */
993 __argp_fmtstream_putc (pest
->stream
, '\n');
994 indent_to (pest
->stream
, uparams
.header_col
);
995 __argp_fmtstream_set_lmargin (pest
->stream
, uparams
.header_col
);
996 __argp_fmtstream_set_wmargin (pest
->stream
, uparams
.header_col
);
997 __argp_fmtstream_puts (pest
->stream
, fstr
);
998 __argp_fmtstream_set_lmargin (pest
->stream
, 0);
999 __argp_fmtstream_putc (pest
->stream
, '\n');
1002 pest
->hhstate
->sep_groups
= 1; /* Separate subsequent groups. */
1006 free ((char *) fstr
);
1009 /* Inserts a comma if this isn't the first item on the line, and then makes
1010 sure we're at least to column COL. If this *is* the first item on a line,
1011 prints any pending whitespace/headers that should precede this line. Also
1014 comma (unsigned col
, struct pentry_state
*pest
)
1018 const struct hol_entry
*pe
= pest
->hhstate
->prev_entry
;
1019 const struct hol_cluster
*cl
= pest
->entry
->cluster
;
1021 if (pest
->hhstate
->sep_groups
&& pe
&& pest
->entry
->group
!= pe
->group
)
1022 __argp_fmtstream_putc (pest
->stream
, '\n');
1024 if (cl
&& cl
->header
&& *cl
->header
1026 || (pe
->cluster
!= cl
1027 && !hol_cluster_is_child (pe
->cluster
, cl
))))
1028 /* If we're changing clusters, then this must be the start of the
1029 ENTRY's cluster unless that is an ancestor of the previous one
1030 (in which case we had just popped into a sub-cluster for a bit).
1031 If so, then print the cluster's header line. */
1033 int old_wm
= __argp_fmtstream_wmargin (pest
->stream
);
1034 print_header (cl
->header
, cl
->argp
, pest
);
1035 __argp_fmtstream_set_wmargin (pest
->stream
, old_wm
);
1041 __argp_fmtstream_puts (pest
->stream
, ", ");
1043 indent_to (pest
->stream
, col
);
1046 /* Print help for ENTRY to STREAM. */
1048 hol_entry_help (struct hol_entry
*entry
, const struct argp_state
*state
,
1049 argp_fmtstream_t stream
, struct hol_help_state
*hhstate
)
1052 const struct argp_option
*real
= entry
->opt
, *opt
;
1053 char *so
= entry
->short_options
;
1054 int have_long_opt
= 0; /* We have any long options. */
1055 /* Saved margins. */
1056 int old_lm
= __argp_fmtstream_set_lmargin (stream
, 0);
1057 int old_wm
= __argp_fmtstream_wmargin (stream
);
1058 /* PEST is a state block holding some of our variables that we'd like to
1059 share with helper functions. */
1060 struct pentry_state pest
= { entry
, stream
, hhstate
, 1, state
};
1063 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1064 if (opt
->name
&& ovisible (opt
))
1070 /* First emit short options. */
1071 __argp_fmtstream_set_wmargin (stream
, uparams
.short_opt_col
); /* For truly bizarre cases. */
1072 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1073 if (oshort (opt
) && opt
->key
== *so
)
1074 /* OPT has a valid (non shadowed) short option. */
1078 comma (uparams
.short_opt_col
, &pest
);
1079 __argp_fmtstream_putc (stream
, '-');
1080 __argp_fmtstream_putc (stream
, *so
);
1081 if (!have_long_opt
|| uparams
.dup_args
)
1082 arg (real
, " %s", "[%s]", state
->root_argp
->argp_domain
, stream
);
1084 hhstate
->suppressed_dup_arg
= 1;
1089 /* Now, long options. */
1091 /* A `documentation' option. */
1093 __argp_fmtstream_set_wmargin (stream
, uparams
.doc_opt_col
);
1094 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1095 if (opt
->name
&& ovisible (opt
))
1097 comma (uparams
.doc_opt_col
, &pest
);
1098 /* Calling gettext here isn't quite right, since sorting will
1099 have been done on the original; but documentation options
1100 should be pretty rare anyway... */
1101 __argp_fmtstream_puts (stream
,
1102 dgettext (state
->root_argp
->argp_domain
,
1107 /* A real long option. */
1109 int first_long_opt
= 1;
1111 __argp_fmtstream_set_wmargin (stream
, uparams
.long_opt_col
);
1112 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1113 if (opt
->name
&& ovisible (opt
))
1115 comma (uparams
.long_opt_col
, &pest
);
1116 __argp_fmtstream_printf (stream
, "--%s", opt
->name
);
1117 if (first_long_opt
|| uparams
.dup_args
)
1118 arg (real
, "=%s", "[=%s]", state
->root_argp
->argp_domain
,
1121 hhstate
->suppressed_dup_arg
= 1;
1125 /* Next, documentation strings. */
1126 __argp_fmtstream_set_lmargin (stream
, 0);
1130 /* Didn't print any switches, what's up? */
1131 if (!oshort (real
) && !real
->name
)
1132 /* This is a group header, print it nicely. */
1133 print_header (real
->doc
, entry
->argp
, &pest
);
1135 /* Just a totally shadowed option or null header; print nothing. */
1136 goto cleanup
; /* Just return, after cleaning up. */
1140 const char *tstr
= real
->doc
? dgettext (state
->root_argp
->argp_domain
,
1142 const char *fstr
= filter_doc (tstr
, real
->key
, entry
->argp
, state
);
1145 unsigned int col
= __argp_fmtstream_point (stream
);
1147 __argp_fmtstream_set_lmargin (stream
, uparams
.opt_doc_col
);
1148 __argp_fmtstream_set_wmargin (stream
, uparams
.opt_doc_col
);
1150 if (col
> (unsigned int) (uparams
.opt_doc_col
+ 3))
1151 __argp_fmtstream_putc (stream
, '\n');
1152 else if (col
>= (unsigned int) uparams
.opt_doc_col
)
1153 __argp_fmtstream_puts (stream
, " ");
1155 indent_to (stream
, uparams
.opt_doc_col
);
1157 __argp_fmtstream_puts (stream
, fstr
);
1159 if (fstr
&& fstr
!= tstr
)
1160 free ((char *) fstr
);
1162 /* Reset the left margin. */
1163 __argp_fmtstream_set_lmargin (stream
, 0);
1164 __argp_fmtstream_putc (stream
, '\n');
1167 hhstate
->prev_entry
= entry
;
1170 __argp_fmtstream_set_lmargin (stream
, old_lm
);
1171 __argp_fmtstream_set_wmargin (stream
, old_wm
);
1174 /* Output a long help message about the options in HOL to STREAM. */
1176 hol_help (struct hol
*hol
, const struct argp_state
*state
,
1177 argp_fmtstream_t stream
)
1180 struct hol_entry
*entry
;
1181 struct hol_help_state hhstate
= { 0, 0, 0 };
1183 for (entry
= hol
->entries
, num
= hol
->num_entries
; num
> 0; entry
++, num
--)
1184 hol_entry_help (entry
, state
, stream
, &hhstate
);
1186 if (hhstate
.suppressed_dup_arg
&& uparams
.dup_args_note
)
1188 const char *tstr
= dgettext (state
->root_argp
->argp_domain
, "\
1189 Mandatory or optional arguments to long options are also mandatory or \
1190 optional for any corresponding short options.");
1191 const char *fstr
= filter_doc (tstr
, ARGP_KEY_HELP_DUP_ARGS_NOTE
,
1192 state
? state
->root_argp
: 0, state
);
1195 __argp_fmtstream_putc (stream
, '\n');
1196 __argp_fmtstream_puts (stream
, fstr
);
1197 __argp_fmtstream_putc (stream
, '\n');
1199 if (fstr
&& fstr
!= tstr
)
1200 free ((char *) fstr
);
1204 /* Helper functions for hol_usage. */
1206 /* If OPT is a short option without an arg, append its key to the string
1207 pointer pointer to by COOKIE, and advance the pointer. */
1209 add_argless_short_opt (const struct argp_option
*opt
,
1210 const struct argp_option
*real
,
1211 const char *domain
, void *cookie
)
1213 char **snao_end
= cookie
;
1214 if (!(opt
->arg
|| real
->arg
)
1215 && !((opt
->flags
| real
->flags
) & OPTION_NO_USAGE
))
1216 *(*snao_end
)++ = opt
->key
;
1220 /* If OPT is a short option with an arg, output a usage entry for it to the
1221 stream pointed at by COOKIE. */
1223 usage_argful_short_opt (const struct argp_option
*opt
,
1224 const struct argp_option
*real
,
1225 const char *domain
, void *cookie
)
1227 argp_fmtstream_t stream
= cookie
;
1228 const char *arg
= opt
->arg
;
1229 int flags
= opt
->flags
| real
->flags
;
1234 if (arg
&& !(flags
& OPTION_NO_USAGE
))
1236 arg
= dgettext (domain
, arg
);
1238 if (flags
& OPTION_ARG_OPTIONAL
)
1239 __argp_fmtstream_printf (stream
, " [-%c[%s]]", opt
->key
, arg
);
1242 /* Manually do line wrapping so that it (probably) won't
1243 get wrapped at the embedded space. */
1244 space (stream
, 6 + strlen (arg
));
1245 __argp_fmtstream_printf (stream
, "[-%c %s]", opt
->key
, arg
);
1252 /* Output a usage entry for the long option opt to the stream pointed at by
1255 usage_long_opt (const struct argp_option
*opt
,
1256 const struct argp_option
*real
,
1257 const char *domain
, void *cookie
)
1259 argp_fmtstream_t stream
= cookie
;
1260 const char *arg
= opt
->arg
;
1261 int flags
= opt
->flags
| real
->flags
;
1266 if (! (flags
& OPTION_NO_USAGE
))
1270 arg
= dgettext (domain
, arg
);
1271 if (flags
& OPTION_ARG_OPTIONAL
)
1272 __argp_fmtstream_printf (stream
, " [--%s[=%s]]", opt
->name
, arg
);
1274 __argp_fmtstream_printf (stream
, " [--%s=%s]", opt
->name
, arg
);
1277 __argp_fmtstream_printf (stream
, " [--%s]", opt
->name
);
1283 /* Print a short usage description for the arguments in HOL to STREAM. */
1285 hol_usage (struct hol
*hol
, argp_fmtstream_t stream
)
1287 if (hol
->num_entries
> 0)
1290 struct hol_entry
*entry
;
1291 char *short_no_arg_opts
= alloca (strlen (hol
->short_options
) + 1);
1292 char *snao_end
= short_no_arg_opts
;
1294 /* First we put a list of short options without arguments. */
1295 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1297 ; entry
++, nentries
--)
1298 hol_entry_short_iterate (entry
, add_argless_short_opt
,
1299 entry
->argp
->argp_domain
, &snao_end
);
1300 if (snao_end
> short_no_arg_opts
)
1303 __argp_fmtstream_printf (stream
, " [-%s]", short_no_arg_opts
);
1306 /* Now a list of short options *with* arguments. */
1307 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1309 ; entry
++, nentries
--)
1310 hol_entry_short_iterate (entry
, usage_argful_short_opt
,
1311 entry
->argp
->argp_domain
, stream
);
1313 /* Finally, a list of long options (whew!). */
1314 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1316 ; entry
++, nentries
--)
1317 hol_entry_long_iterate (entry
, usage_long_opt
,
1318 entry
->argp
->argp_domain
, stream
);
1322 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1323 cluster in which ARGP's entries should be clustered, or 0. */
1325 argp_hol (const struct argp
*argp
, struct hol_cluster
*cluster
)
1327 const struct argp_child
*child
= argp
->children
;
1328 struct hol
*hol
= make_hol (argp
, cluster
);
1332 struct hol_cluster
*child_cluster
=
1333 ((child
->group
|| child
->header
)
1334 /* Put CHILD->argp within its own cluster. */
1335 ? hol_add_cluster (hol
, child
->group
, child
->header
,
1336 child
- argp
->children
, cluster
, argp
)
1337 /* Just merge it into the parent's cluster. */
1339 hol_append (hol
, argp_hol (child
->argp
, child_cluster
)) ;
1345 /* Calculate how many different levels with alternative args strings exist in
1348 argp_args_levels (const struct argp
*argp
)
1351 const struct argp_child
*child
= argp
->children
;
1353 if (argp
->args_doc
&& strchr (argp
->args_doc
, '\n'))
1358 levels
+= argp_args_levels ((child
++)->argp
);
1363 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1364 preceded by a space. LEVELS is a pointer to a byte vector the length
1365 returned by argp_args_levels; it should be initialized to zero, and
1366 updated by this routine for the next call if ADVANCE is true. True is
1367 returned as long as there are more patterns to output. */
1369 argp_args_usage (const struct argp
*argp
, const struct argp_state
*state
,
1370 char **levels
, int advance
, argp_fmtstream_t stream
)
1372 char *our_level
= *levels
;
1374 const struct argp_child
*child
= argp
->children
;
1375 const char *tdoc
= dgettext (argp
->argp_domain
, argp
->args_doc
), *nl
= 0;
1376 const char *fdoc
= filter_doc (tdoc
, ARGP_KEY_HELP_ARGS_DOC
, argp
, state
);
1380 const char *cp
= fdoc
;
1381 nl
= __strchrnul (cp
, '\n');
1383 /* This is a `multi-level' args doc; advance to the correct position
1384 as determined by our state in LEVELS, and update LEVELS. */
1388 for (i
= 0; i
< *our_level
; i
++)
1389 cp
= nl
+ 1, nl
= __strchrnul (cp
, '\n');
1393 /* Manually do line wrapping so that it (probably) won't get wrapped at
1394 any embedded spaces. */
1395 space (stream
, 1 + nl
- cp
);
1397 __argp_fmtstream_write (stream
, cp
, nl
- cp
);
1399 if (fdoc
&& fdoc
!= tdoc
)
1400 free ((char *)fdoc
); /* Free user's modified doc string. */
1404 advance
= !argp_args_usage ((child
++)->argp
, state
, levels
, advance
, stream
);
1406 if (advance
&& multiple
)
1408 /* Need to increment our level. */
1410 /* There's more we can do here. */
1413 advance
= 0; /* Our parent shouldn't advance also. */
1415 else if (*our_level
> 0)
1416 /* We had multiple levels, but used them up; reset to zero. */
1423 /* Print the documentation for ARGP to STREAM; if POST is false, then
1424 everything preceeding a `\v' character in the documentation strings (or
1425 the whole string, for those with none) is printed, otherwise, everything
1426 following the `\v' character (nothing for strings without). Each separate
1427 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1428 then the first is as well. If FIRST_ONLY is true, only the first
1429 occurrence is output. Returns true if anything was output. */
1431 argp_doc (const struct argp
*argp
, const struct argp_state
*state
,
1432 int post
, int pre_blank
, int first_only
,
1433 argp_fmtstream_t stream
)
1436 const char *inp_text
;
1439 size_t inp_text_limit
= 0;
1440 const char *doc
= dgettext (argp
->argp_domain
, argp
->doc
);
1441 const struct argp_child
*child
= argp
->children
;
1445 char *vt
= strchr (doc
, '\v');
1446 inp_text
= post
? (vt
? vt
+ 1 : 0) : doc
;
1447 inp_text_limit
= (!post
&& vt
) ? (vt
- doc
) : 0;
1452 if (argp
->help_filter
)
1453 /* We have to filter the doc strings. */
1456 /* Copy INP_TEXT so that it's nul-terminated. */
1457 inp_text
= __strndup (inp_text
, inp_text_limit
);
1458 input
= __argp_input (argp
, state
);
1460 (*argp
->help_filter
) (post
1461 ? ARGP_KEY_HELP_POST_DOC
1462 : ARGP_KEY_HELP_PRE_DOC
,
1466 text
= (const char *) inp_text
;
1471 __argp_fmtstream_putc (stream
, '\n');
1473 if (text
== inp_text
&& inp_text_limit
)
1474 __argp_fmtstream_write (stream
, inp_text
, inp_text_limit
);
1476 __argp_fmtstream_puts (stream
, text
);
1478 if (__argp_fmtstream_point (stream
) > __argp_fmtstream_lmargin (stream
))
1479 __argp_fmtstream_putc (stream
, '\n');
1484 if (text
&& text
!= inp_text
)
1485 free ((char *) text
); /* Free TEXT returned from the help filter. */
1486 if (inp_text
&& inp_text_limit
&& argp
->help_filter
)
1487 free ((char *) inp_text
); /* We copied INP_TEXT, so free it now. */
1489 if (post
&& argp
->help_filter
)
1490 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1492 text
= (*argp
->help_filter
) (ARGP_KEY_HELP_EXTRA
, 0, input
);
1495 if (anything
|| pre_blank
)
1496 __argp_fmtstream_putc (stream
, '\n');
1497 __argp_fmtstream_puts (stream
, text
);
1498 free ((char *) text
);
1499 if (__argp_fmtstream_point (stream
)
1500 > __argp_fmtstream_lmargin (stream
))
1501 __argp_fmtstream_putc (stream
, '\n');
1507 while (child
->argp
&& !(first_only
&& anything
))
1509 argp_doc ((child
++)->argp
, state
,
1510 post
, anything
|| pre_blank
, first_only
,
1516 /* Output a usage message for ARGP to STREAM. If called from
1517 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1518 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1521 _help (const struct argp
*argp
, const struct argp_state
*state
, FILE *stream
,
1522 unsigned flags
, char *name
)
1524 int anything
= 0; /* Whether we've output anything. */
1525 struct hol
*hol
= 0;
1526 argp_fmtstream_t fs
;
1531 __flockfile (stream
);
1533 if (! uparams
.valid
)
1534 fill_in_uparams (state
);
1536 fs
= __argp_make_fmtstream (stream
, 0, uparams
.rmargin
, 0);
1539 __funlockfile (stream
);
1543 if (flags
& (ARGP_HELP_USAGE
| ARGP_HELP_SHORT_USAGE
| ARGP_HELP_LONG
))
1545 hol
= argp_hol (argp
, 0);
1547 /* If present, these options always come last. */
1548 hol_set_group (hol
, "help", -1);
1549 hol_set_group (hol
, "version", -1);
1554 if (flags
& (ARGP_HELP_USAGE
| ARGP_HELP_SHORT_USAGE
))
1555 /* Print a short `Usage:' message. */
1557 int first_pattern
= 1, more_patterns
;
1558 size_t num_pattern_levels
= argp_args_levels (argp
);
1559 char *pattern_levels
= alloca (num_pattern_levels
);
1561 memset (pattern_levels
, 0, num_pattern_levels
);
1566 int old_wm
= __argp_fmtstream_set_wmargin (fs
, uparams
.usage_indent
);
1567 char *levels
= pattern_levels
;
1570 __argp_fmtstream_printf (fs
, "%s %s",
1571 dgettext (argp
->argp_domain
, "Usage:"),
1574 __argp_fmtstream_printf (fs
, "%s %s",
1575 dgettext (argp
->argp_domain
, " or: "),
1578 /* We set the lmargin as well as the wmargin, because hol_usage
1579 manually wraps options with newline to avoid annoying breaks. */
1580 old_lm
= __argp_fmtstream_set_lmargin (fs
, uparams
.usage_indent
);
1582 if (flags
& ARGP_HELP_SHORT_USAGE
)
1583 /* Just show where the options go. */
1585 if (hol
->num_entries
> 0)
1586 __argp_fmtstream_puts (fs
, dgettext (argp
->argp_domain
,
1590 /* Actually print the options. */
1592 hol_usage (hol
, fs
);
1593 flags
|= ARGP_HELP_SHORT_USAGE
; /* But only do so once. */
1596 more_patterns
= argp_args_usage (argp
, state
, &levels
, 1, fs
);
1598 __argp_fmtstream_set_wmargin (fs
, old_wm
);
1599 __argp_fmtstream_set_lmargin (fs
, old_lm
);
1601 __argp_fmtstream_putc (fs
, '\n');
1606 while (more_patterns
);
1609 if (flags
& ARGP_HELP_PRE_DOC
)
1610 anything
|= argp_doc (argp
, state
, 0, 0, 1, fs
);
1612 if (flags
& ARGP_HELP_SEE
)
1614 __argp_fmtstream_printf (fs
, dgettext (argp
->argp_domain
, "\
1615 Try `%s --help' or `%s --usage' for more information.\n"),
1620 if (flags
& ARGP_HELP_LONG
)
1621 /* Print a long, detailed help message. */
1623 /* Print info about all the options. */
1624 if (hol
->num_entries
> 0)
1627 __argp_fmtstream_putc (fs
, '\n');
1628 hol_help (hol
, state
, fs
);
1633 if (flags
& ARGP_HELP_POST_DOC
)
1634 /* Print any documentation strings at the end. */
1635 anything
|= argp_doc (argp
, state
, 1, anything
, 0, fs
);
1637 if ((flags
& ARGP_HELP_BUG_ADDR
) && argp_program_bug_address
)
1640 __argp_fmtstream_putc (fs
, '\n');
1641 __argp_fmtstream_printf (fs
, dgettext (argp
->argp_domain
,
1642 "Report bugs to %s.\n"),
1643 argp_program_bug_address
);
1647 __funlockfile (stream
);
1652 __argp_fmtstream_free (fs
);
1655 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1656 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1657 void __argp_help (const struct argp
*argp
, FILE *stream
,
1658 unsigned flags
, char *name
)
1660 _help (argp
, 0, stream
, flags
, name
);
1663 weak_alias (__argp_help
, argp_help
)
1666 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1667 from the set ARGP_HELP_*. */
1669 __argp_state_help (const struct argp_state
*state
, FILE *stream
, unsigned flags
)
1671 if ((!state
|| ! (state
->flags
& ARGP_NO_ERRS
)) && stream
)
1673 if (state
&& (state
->flags
& ARGP_LONG_ONLY
))
1674 flags
|= ARGP_HELP_LONG_ONLY
;
1676 _help (state
? state
->root_argp
: 0, state
, stream
, flags
,
1677 state
? state
->name
: program_invocation_short_name
);
1679 if (!state
|| ! (state
->flags
& ARGP_NO_EXIT
))
1681 if (flags
& ARGP_HELP_EXIT_ERR
)
1682 exit (argp_err_exit_status
);
1683 if (flags
& ARGP_HELP_EXIT_OK
)
1689 weak_alias (__argp_state_help
, argp_state_help
)
1692 /* If appropriate, print the printf string FMT and following args, preceded
1693 by the program name and `:', to stderr, and followed by a `Try ... --help'
1694 message, then exit (1). */
1696 __argp_error (const struct argp_state
*state
, const char *fmt
, ...)
1698 if (!state
|| !(state
->flags
& ARGP_NO_ERRS
))
1700 FILE *stream
= state
? state
->err_stream
: stderr
;
1706 __flockfile (stream
);
1711 if (_IO_fwide (stream
, 0) > 0)
1715 __asprintf (&buf
, fmt
, ap
);
1717 __fwprintf (stream
, L
"%s: %s\n",
1718 state
? state
->name
: program_invocation_short_name
,
1726 fputs_unlocked (state
1727 ? state
->name
: program_invocation_short_name
,
1729 putc_unlocked (':', stream
);
1730 putc_unlocked (' ', stream
);
1732 vfprintf (stream
, fmt
, ap
);
1734 putc_unlocked ('\n', stream
);
1737 __argp_state_help (state
, stream
, ARGP_HELP_STD_ERR
);
1741 __funlockfile (stream
);
1746 weak_alias (__argp_error
, argp_error
)
1749 /* Similar to the standard gnu error-reporting function error(), but will
1750 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1751 to STATE->err_stream. This is useful for argument parsing code that is
1752 shared between program startup (when exiting is desired) and runtime
1753 option parsing (when typically an error code is returned instead). The
1754 difference between this function and argp_error is that the latter is for
1755 *parsing errors*, and the former is for other problems that occur during
1756 parsing but don't reflect a (syntactic) problem with the input. */
1758 __argp_failure (const struct argp_state
*state
, int status
, int errnum
,
1759 const char *fmt
, ...)
1761 if (!state
|| !(state
->flags
& ARGP_NO_ERRS
))
1763 FILE *stream
= state
? state
->err_stream
: stderr
;
1767 __flockfile (stream
);
1770 if (_IO_fwide (stream
, 0) > 0)
1771 __fwprintf (stream
, L
"%s",
1772 state
? state
->name
: program_invocation_short_name
);
1775 fputs_unlocked (state
1776 ? state
->name
: program_invocation_short_name
,
1785 if (_IO_fwide (stream
, 0) > 0)
1789 __asprintf (&buf
, fmt
, ap
);
1791 __fwprintf (stream
, L
": %s", buf
);
1798 putc_unlocked (':', stream
);
1799 putc_unlocked (' ', stream
);
1801 vfprintf (stream
, fmt
, ap
);
1812 if (_IO_fwide (stream
, 0) > 0)
1813 __fwprintf (stream
, L
": %s",
1814 __strerror_r (errnum
, buf
, sizeof (buf
)));
1818 putc_unlocked (':', stream
);
1819 putc_unlocked (' ', stream
);
1820 fputs (__strerror_r (errnum
, buf
, sizeof (buf
)), stream
);
1825 if (_IO_fwide (stream
, 0) > 0)
1826 putwc_unlocked (L
'\n', stream
);
1829 putc_unlocked ('\n', stream
);
1831 __funlockfile (stream
);
1833 if (status
&& (!state
|| !(state
->flags
& ARGP_NO_EXIT
)))
1839 weak_alias (__argp_failure
, argp_failure
)