1 /* Hierarchial argument parsing help output
2 Copyright (C) 1995,1996,1997,1998,1999,2000 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
57 /* This is for other GNU distributions with internationalized messages. */
58 # if defined HAVE_LIBINTL_H || defined _LIBC
62 # define dgettext(domain, msgid) __dcgettext (domain, msgid, LC_MESSAGES)
65 # define dgettext(domain, msgid) (msgid)
70 #include "argp-fmtstream.h"
71 #include "argp-namefrob.h"
73 /* User-selectable (using an environment variable) formatting parameters.
75 These may be specified in an environment variable called `ARGP_HELP_FMT',
76 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
77 Where VALn must be a positive integer. The list of variables is in the
78 UPARAM_NAMES vector, below. */
80 /* Default parameters. */
81 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
82 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
83 #define SHORT_OPT_COL 2 /* column in which short options start */
84 #define LONG_OPT_COL 6 /* column in which long options start */
85 #define DOC_OPT_COL 2 /* column in which doc options start */
86 #define OPT_DOC_COL 29 /* column in which option text starts */
87 #define HEADER_COL 1 /* column in which group headers are printed */
88 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
89 #define RMARGIN 79 /* right margin used for wrapping */
91 /* User-selectable (using an environment variable) formatting parameters.
92 They must all be of type `int' for the parsing code to work. */
95 /* If true, arguments for an option are shown with both short and long
96 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
97 If false, then if an option has both, the argument is only shown with
98 the long one, e.g., `-x, --longx=ARG', and a message indicating that
99 this really means both is printed below the options. */
102 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
103 been suppressed, an explanatory message should be printed. */
106 /* Various output columns. */
115 int valid
; /* True when the values in here are valid. */
118 /* This is a global variable, as user options are only ever read once. */
119 static struct uparams uparams
= {
120 DUP_ARGS
, DUP_ARGS_NOTE
,
121 SHORT_OPT_COL
, LONG_OPT_COL
, DOC_OPT_COL
, OPT_DOC_COL
, HEADER_COL
,
122 USAGE_INDENT
, RMARGIN
,
126 /* A particular uparam, and what the user name is. */
129 const char *name
; /* User name. */
130 int is_bool
; /* Whether it's `boolean'. */
131 size_t uparams_offs
; /* Location of the (int) field in UPARAMS. */
134 /* The name-field mappings we know about. */
135 static const struct uparam_name uparam_names
[] =
137 { "dup-args", 1, offsetof (struct uparams
, dup_args
) },
138 { "dup-args-note", 1, offsetof (struct uparams
, dup_args_note
) },
139 { "short-opt-col", 0, offsetof (struct uparams
, short_opt_col
) },
140 { "long-opt-col", 0, offsetof (struct uparams
, long_opt_col
) },
141 { "doc-opt-col", 0, offsetof (struct uparams
, doc_opt_col
) },
142 { "opt-doc-col", 0, offsetof (struct uparams
, opt_doc_col
) },
143 { "header-col", 0, offsetof (struct uparams
, header_col
) },
144 { "usage-indent", 0, offsetof (struct uparams
, usage_indent
) },
145 { "rmargin", 0, offsetof (struct uparams
, rmargin
) },
149 /* Read user options from the environment, and fill in UPARAMS appropiately. */
151 fill_in_uparams (const struct argp_state
*state
)
153 const char *var
= getenv ("ARGP_HELP_FMT");
155 #define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
166 const struct uparam_name
*un
;
167 int unspec
= 0, val
= 0;
168 const char *arg
= var
;
170 while (isalnum (*arg
) || *arg
== '-' || *arg
== '_')
176 if (*arg
== '\0' || *arg
== ',')
178 else if (*arg
== '=')
186 if (var
[0] == 'n' && var
[1] == 'o' && var
[2] == '-')
195 else if (isdigit (*arg
))
198 while (isdigit (*arg
))
203 for (un
= uparam_names
; un
->name
; un
++)
204 if (strlen (un
->name
) == var_len
205 && strncmp (var
, un
->name
, var_len
) == 0)
207 if (unspec
&& !un
->is_bool
)
208 __argp_failure (state
, 0, 0,
209 dgettext (state
->root_argp
->argp_domain
, "\
210 %.*s: ARGP_HELP_FMT parameter requires a value"),
213 *(int *)((char *)&uparams
+ un
->uparams_offs
) = val
;
217 __argp_failure (state
, 0, 0,
218 dgettext (state
->root_argp
->argp_domain
, "\
219 %.*s: Unknown ARGP_HELP_FMT parameter"),
228 __argp_failure (state
, 0, 0,
229 dgettext (state
->root_argp
->argp_domain
,
230 "Garbage in ARGP_HELP_FMT: %s"), var
);
236 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
237 whether OPT is displayed or used in sorting, not option shadowing. */
238 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
240 /* Returns true if OPT is an alias for an earlier option. */
241 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
243 /* Returns true if OPT is an documentation-only entry. */
244 #define odoc(opt) ((opt)->flags & OPTION_DOC)
246 /* Returns true if OPT is the end-of-list marker for a list of options. */
247 #define oend(opt) __option_is_end (opt)
249 /* Returns true if OPT has a short option. */
250 #define oshort(opt) __option_is_short (opt)
253 The help format for a particular option is like:
255 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
257 Where ARG will be omitted if there's no argument, for this option, or
258 will be surrounded by "[" and "]" appropiately if the argument is
259 optional. The documentation string is word-wrapped appropiately, and if
260 the list of options is long enough, it will be started on a separate line.
261 If there are no short options for a given option, the first long option is
262 indented slighly in a way that's supposed to make most long options appear
263 to be in a separate column.
265 For example, the following output (from ps):
267 -p PID, --pid=PID List the process PID
268 --pgrp=PGRP List processes in the process group PGRP
269 -P, -x, --no-parent Include processes without parents
270 -Q, --all-fields Don't elide unusable fields (normally if there's
271 some reason ps can't print a field for any
272 process, it's removed from the output entirely)
273 -r, --reverse, --gratuitously-long-reverse-option
274 Reverse the order of any sort
275 --session[=SID] Add the processes from the session SID (which
276 defaults to the sid of the current process)
278 Here are some more options:
279 -f ZOT, --foonly=ZOT Glork a foonly
280 -z, --zaza Snit a zar
282 -?, --help Give this help list
283 --usage Give a short usage message
284 -V, --version Print program version
286 The struct argp_option array for the above could look like:
289 {"pid", 'p', "PID", 0, "List the process PID"},
290 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
291 {"no-parent", 'P', 0, 0, "Include processes without parents"},
292 {0, 'x', 0, OPTION_ALIAS},
293 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
294 " if there's some reason ps can't"
295 " print a field for any process, it's"
296 " removed from the output entirely)" },
297 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
298 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
299 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
300 "Add the processes from the session"
301 " SID (which defaults to the sid of"
302 " the current process)" },
304 {0,0,0,0, "Here are some more options:"},
305 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
306 {"zaza", 'z', 0, 0, "Snit a zar"},
311 Note that the last three options are automatically supplied by argp_parse,
312 unless you tell it not to with ARGP_NO_HELP.
316 /* Returns true if CH occurs between BEG and END. */
318 find_char (char ch
, char *beg
, char *end
)
328 struct hol_cluster
; /* fwd decl */
333 const struct argp_option
*opt
;
334 /* Number of options (including aliases). */
337 /* A pointers into the HOL's short_options field, to the first short option
338 letter for this entry. The order of the characters following this point
339 corresponds to the order of options pointed to by OPT, and there are at
340 most NUM. A short option recorded in a option following OPT is only
341 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
342 probably been shadowed by some other entry). */
345 /* Entries are sorted by their group first, in the order:
346 1, 2, ..., n, 0, -m, ..., -2, -1
347 and then alphabetically within each group. The default is 0. */
350 /* The cluster of options this entry belongs to, or 0 if none. */
351 struct hol_cluster
*cluster
;
353 /* The argp from which this option came. */
354 const struct argp
*argp
;
357 /* A cluster of entries to reflect the argp tree structure. */
360 /* A descriptive header printed before options in this cluster. */
363 /* Used to order clusters within the same group with the same parent,
364 according to the order in which they occurred in the parent argp's child
368 /* How to sort this cluster with respect to options and other clusters at the
369 same depth (clusters always follow options in the same group). */
372 /* The cluster to which this cluster belongs, or 0 if it's at the base
374 struct hol_cluster
*parent
;
376 /* The argp from which this cluster is (eventually) derived. */
377 const struct argp
*argp
;
379 /* The distance this cluster is from the root. */
382 /* Clusters in a given hol are kept in a linked list, to make freeing them
384 struct hol_cluster
*next
;
387 /* A list of options for help. */
390 /* An array of hol_entry's. */
391 struct hol_entry
*entries
;
392 /* The number of entries in this hol. If this field is zero, the others
394 unsigned num_entries
;
396 /* A string containing all short options in this HOL. Each entry contains
397 pointers into this string, so the order can't be messed with blindly. */
400 /* Clusters of entries in this hol. */
401 struct hol_cluster
*clusters
;
404 /* Create a struct hol from the options in ARGP. CLUSTER is the
405 hol_cluster in which these entries occur, or 0, if at the root. */
407 make_hol (const struct argp
*argp
, struct hol_cluster
*cluster
)
410 const struct argp_option
*o
;
411 const struct argp_option
*opts
= argp
->options
;
412 struct hol_entry
*entry
;
413 unsigned num_short_options
= 0;
414 struct hol
*hol
= malloc (sizeof (struct hol
));
418 hol
->num_entries
= 0;
425 /* The first option must not be an alias. */
426 assert (! oalias (opts
));
428 /* Calculate the space needed. */
429 for (o
= opts
; ! oend (o
); o
++)
434 num_short_options
++; /* This is an upper bound. */
437 hol
->entries
= malloc (sizeof (struct hol_entry
) * hol
->num_entries
);
438 hol
->short_options
= malloc (num_short_options
+ 1);
440 assert (hol
->entries
&& hol
->short_options
);
442 /* Fill in the entries. */
443 so
= hol
->short_options
;
444 for (o
= opts
, entry
= hol
->entries
; ! oend (o
); entry
++)
448 entry
->short_options
= so
;
449 entry
->group
= cur_group
=
452 : ((!o
->name
&& !o
->key
)
455 entry
->cluster
= cluster
;
461 if (oshort (o
) && ! find_char (o
->key
, hol
->short_options
, so
))
462 /* O has a valid short option which hasn't already been used.*/
466 while (! oend (o
) && oalias (o
));
468 *so
= '\0'; /* null terminated so we can find the length */
474 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
475 associated argp child list entry), INDEX, and PARENT, and return a pointer
476 to it. ARGP is the argp that this cluster results from. */
477 static struct hol_cluster
*
478 hol_add_cluster (struct hol
*hol
, int group
, const char *header
, int index
,
479 struct hol_cluster
*parent
, const struct argp
*argp
)
481 struct hol_cluster
*cl
= malloc (sizeof (struct hol_cluster
));
490 cl
->depth
= parent
? parent
->depth
+ 1 : 0;
492 cl
->next
= hol
->clusters
;
498 /* Free HOL and any resources it uses. */
500 hol_free (struct hol
*hol
)
502 struct hol_cluster
*cl
= hol
->clusters
;
506 struct hol_cluster
*next
= cl
->next
;
511 if (hol
->num_entries
> 0)
514 free (hol
->short_options
);
521 hol_entry_short_iterate (const struct hol_entry
*entry
,
522 int (*func
)(const struct argp_option
*opt
,
523 const struct argp_option
*real
,
524 const char *domain
, void *cookie
),
525 const char *domain
, void *cookie
)
529 const struct argp_option
*opt
, *real
= entry
->opt
;
530 char *so
= entry
->short_options
;
532 for (opt
= real
, nopts
= entry
->num
; nopts
> 0 && !val
; opt
++, nopts
--)
533 if (oshort (opt
) && *so
== opt
->key
)
538 val
= (*func
)(opt
, real
, domain
, cookie
);
546 hol_entry_long_iterate (const struct hol_entry
*entry
,
547 int (*func
)(const struct argp_option
*opt
,
548 const struct argp_option
*real
,
549 const char *domain
, void *cookie
),
550 const char *domain
, void *cookie
)
554 const struct argp_option
*opt
, *real
= entry
->opt
;
556 for (opt
= real
, nopts
= entry
->num
; nopts
> 0 && !val
; opt
++, nopts
--)
562 val
= (*func
)(opt
, real
, domain
, cookie
);
568 /* Iterator that returns true for the first short option. */
570 until_short (const struct argp_option
*opt
, const struct argp_option
*real
,
571 const char *domain
, void *cookie
)
573 return oshort (opt
) ? opt
->key
: 0;
576 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
578 hol_entry_first_short (const struct hol_entry
*entry
)
580 return hol_entry_short_iterate (entry
, until_short
,
581 entry
->argp
->argp_domain
, 0);
584 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
586 hol_entry_first_long (const struct hol_entry
*entry
)
588 const struct argp_option
*opt
;
590 for (opt
= entry
->opt
, num
= entry
->num
; num
> 0; opt
++, num
--)
591 if (opt
->name
&& ovisible (opt
))
596 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
598 static struct hol_entry
*
599 hol_find_entry (struct hol
*hol
, const char *name
)
601 struct hol_entry
*entry
= hol
->entries
;
602 unsigned num_entries
= hol
->num_entries
;
604 while (num_entries
-- > 0)
606 const struct argp_option
*opt
= entry
->opt
;
607 unsigned num_opts
= entry
->num
;
609 while (num_opts
-- > 0)
610 if (opt
->name
&& ovisible (opt
) && strcmp (opt
->name
, name
) == 0)
621 /* If an entry with the long option NAME occurs in HOL, set it's special
622 sort position to GROUP. */
624 hol_set_group (struct hol
*hol
, const char *name
, int group
)
626 struct hol_entry
*entry
= hol_find_entry (hol
, name
);
628 entry
->group
= group
;
631 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
632 EQ is what to return if GROUP1 and GROUP2 are the same. */
634 group_cmp (int group1
, int group2
, int eq
)
636 if (group1
== group2
)
638 else if ((group1
< 0 && group2
< 0) || (group1
>= 0 && group2
>= 0))
639 return group1
- group2
;
641 return group2
- group1
;
644 /* Compare clusters CL1 & CL2 by the order that they should appear in
647 hol_cluster_cmp (const struct hol_cluster
*cl1
, const struct hol_cluster
*cl2
)
649 /* If one cluster is deeper than the other, use its ancestor at the same
650 level, so that finding the common ancestor is straightforward. */
651 while (cl1
->depth
< cl2
->depth
)
653 while (cl2
->depth
< cl1
->depth
)
656 /* Now reduce both clusters to their ancestors at the point where both have
657 a common parent; these can be directly compared. */
658 while (cl1
->parent
!= cl2
->parent
)
659 cl1
= cl1
->parent
, cl2
= cl2
->parent
;
661 return group_cmp (cl1
->group
, cl2
->group
, cl2
->index
- cl1
->index
);
664 /* Return the ancestor of CL that's just below the root (i.e., has a parent
666 static struct hol_cluster
*
667 hol_cluster_base (struct hol_cluster
*cl
)
674 /* Return true if CL1 is a child of CL2. */
676 hol_cluster_is_child (const struct hol_cluster
*cl1
,
677 const struct hol_cluster
*cl2
)
679 while (cl1
&& cl1
!= cl2
)
684 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
685 that should be used for comparisons, and returns true iff it should be
686 treated as a non-option. */
688 canon_doc_option (const char **name
)
691 /* Skip initial whitespace. */
692 while (isspace (**name
))
694 /* Decide whether this looks like an option (leading `-') or not. */
695 non_opt
= (**name
!= '-');
696 /* Skip until part of name used for sorting. */
697 while (**name
&& !isalnum (**name
))
702 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
705 hol_entry_cmp (const struct hol_entry
*entry1
,
706 const struct hol_entry
*entry2
)
708 /* The group numbers by which the entries should be ordered; if either is
709 in a cluster, then this is just the group within the cluster. */
710 int group1
= entry1
->group
, group2
= entry2
->group
;
712 if (entry1
->cluster
!= entry2
->cluster
)
714 /* The entries are not within the same cluster, so we can't compare them
715 directly, we have to use the appropiate clustering level too. */
716 if (! entry1
->cluster
)
717 /* ENTRY1 is at the `base level', not in a cluster, so we have to
718 compare it's group number with that of the base cluster in which
719 ENTRY2 resides. Note that if they're in the same group, the
720 clustered option always comes laster. */
721 return group_cmp (group1
, hol_cluster_base (entry2
->cluster
)->group
, -1);
722 else if (! entry2
->cluster
)
723 /* Likewise, but ENTRY2's not in a cluster. */
724 return group_cmp (hol_cluster_base (entry1
->cluster
)->group
, group2
, 1);
726 /* Both entries are in clusters, we can just compare the clusters. */
727 return hol_cluster_cmp (entry1
->cluster
, entry2
->cluster
);
729 else if (group1
== group2
)
730 /* The entries are both in the same cluster and group, so compare them
733 int short1
= hol_entry_first_short (entry1
);
734 int short2
= hol_entry_first_short (entry2
);
735 int doc1
= odoc (entry1
->opt
);
736 int doc2
= odoc (entry2
->opt
);
737 const char *long1
= hol_entry_first_long (entry1
);
738 const char *long2
= hol_entry_first_long (entry2
);
741 doc1
= canon_doc_option (&long1
);
743 doc2
= canon_doc_option (&long2
);
746 /* `documentation' options always follow normal options (or
747 documentation options that *look* like normal options). */
749 else if (!short1
&& !short2
&& long1
&& long2
)
750 /* Only long options. */
751 return __strcasecmp (long1
, long2
);
753 /* Compare short/short, long/short, short/long, using the first
754 character of long options. Entries without *any* valid
755 options (such as options with OPTION_HIDDEN set) will be put
756 first, but as they're not displayed, it doesn't matter where
759 char first1
= short1
? short1
: long1
? *long1
: 0;
760 char first2
= short2
? short2
: long2
? *long2
: 0;
762 int lower_cmp
= _tolower (first1
) - _tolower (first2
);
764 int lower_cmp
= tolower (first1
) - tolower (first2
);
766 /* Compare ignoring case, except when the options are both the
767 same letter, in which case lower-case always comes first. */
768 return lower_cmp
? lower_cmp
: first2
- first1
;
772 /* Within the same cluster, but not the same group, so just compare
774 return group_cmp (group1
, group2
, 0);
777 /* Version of hol_entry_cmp with correct signature for qsort. */
779 hol_entry_qcmp (const void *entry1_v
, const void *entry2_v
)
781 return hol_entry_cmp (entry1_v
, entry2_v
);
784 /* Sort HOL by group and alphabetically by option name (with short options
785 taking precedence over long). Since the sorting is for display purposes
786 only, the shadowing of options isn't effected. */
788 hol_sort (struct hol
*hol
)
790 if (hol
->num_entries
> 0)
791 qsort (hol
->entries
, hol
->num_entries
, sizeof (struct hol_entry
),
795 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
796 any in MORE with the same name. */
798 hol_append (struct hol
*hol
, struct hol
*more
)
800 struct hol_cluster
**cl_end
= &hol
->clusters
;
802 /* Steal MORE's cluster list, and add it to the end of HOL's. */
804 cl_end
= &(*cl_end
)->next
;
805 *cl_end
= more
->clusters
;
809 if (more
->num_entries
> 0)
811 if (hol
->num_entries
== 0)
813 hol
->num_entries
= more
->num_entries
;
814 hol
->entries
= more
->entries
;
815 hol
->short_options
= more
->short_options
;
816 more
->num_entries
= 0; /* Mark MORE's fields as invalid. */
819 /* Append the entries in MORE to those in HOL, taking care to only add
820 non-shadowed SHORT_OPTIONS values. */
825 unsigned num_entries
= hol
->num_entries
+ more
->num_entries
;
826 struct hol_entry
*entries
=
827 malloc (num_entries
* sizeof (struct hol_entry
));
828 unsigned hol_so_len
= strlen (hol
->short_options
);
829 char *short_options
=
830 malloc (hol_so_len
+ strlen (more
->short_options
) + 1);
832 __mempcpy (__mempcpy (entries
, hol
->entries
,
833 hol
->num_entries
* sizeof (struct hol_entry
)),
835 more
->num_entries
* sizeof (struct hol_entry
));
837 __mempcpy (short_options
, hol
->short_options
, hol_so_len
);
839 /* Fix up the short options pointers from HOL. */
840 for (e
= entries
, left
= hol
->num_entries
; left
> 0; e
++, left
--)
841 e
->short_options
+= (short_options
- hol
->short_options
);
843 /* Now add the short options from MORE, fixing up its entries
845 so
= short_options
+ hol_so_len
;
846 more_so
= more
->short_options
;
847 for (left
= more
->num_entries
; left
> 0; e
++, left
--)
850 const struct argp_option
*opt
;
852 e
->short_options
= so
;
854 for (opts_left
= e
->num
, opt
= e
->opt
; opts_left
; opt
++, opts_left
--)
857 if (oshort (opt
) && ch
== opt
->key
)
858 /* The next short option in MORE_SO, CH, is from OPT. */
860 if (! find_char (ch
, short_options
,
861 short_options
+ hol_so_len
))
862 /* The short option CH isn't shadowed by HOL's options,
863 so add it to the sum. */
873 free (hol
->short_options
);
875 hol
->entries
= entries
;
876 hol
->num_entries
= num_entries
;
877 hol
->short_options
= short_options
;
884 /* Inserts enough spaces to make sure STREAM is at column COL. */
886 indent_to (argp_fmtstream_t stream
, unsigned col
)
888 int needed
= col
- __argp_fmtstream_point (stream
);
890 __argp_fmtstream_putc (stream
, ' ');
893 /* Output to STREAM either a space, or a newline if there isn't room for at
894 least ENSURE characters before the right margin. */
896 space (argp_fmtstream_t stream
, size_t ensure
)
898 if (__argp_fmtstream_point (stream
) + ensure
899 >= __argp_fmtstream_rmargin (stream
))
900 __argp_fmtstream_putc (stream
, '\n');
902 __argp_fmtstream_putc (stream
, ' ');
905 /* If the option REAL has an argument, we print it in using the printf
906 format REQ_FMT or OPT_FMT depending on whether it's a required or
907 optional argument. */
909 arg (const struct argp_option
*real
, const char *req_fmt
, const char *opt_fmt
,
910 const char *domain
, argp_fmtstream_t stream
)
914 if (real
->flags
& OPTION_ARG_OPTIONAL
)
915 __argp_fmtstream_printf (stream
, opt_fmt
,
916 dgettext (domain
, real
->arg
));
918 __argp_fmtstream_printf (stream
, req_fmt
,
919 dgettext (domain
, real
->arg
));
923 /* Helper functions for hol_entry_help. */
925 /* State used during the execution of hol_help. */
926 struct hol_help_state
928 /* PREV_ENTRY should contain the previous entry printed, or 0. */
929 struct hol_entry
*prev_entry
;
931 /* If an entry is in a different group from the previous one, and SEP_GROUPS
932 is true, then a blank line will be printed before any output. */
935 /* True if a duplicate option argument was suppressed (only ever set if
936 UPARAMS.dup_args is false). */
937 int suppressed_dup_arg
;
940 /* Some state used while printing a help entry (used to communicate with
941 helper functions). See the doc for hol_entry_help for more info, as most
942 of the fields are copied from its arguments. */
945 const struct hol_entry
*entry
;
946 argp_fmtstream_t stream
;
947 struct hol_help_state
*hhstate
;
949 /* True if nothing's been printed so far. */
952 /* If non-zero, the state that was used to print this help. */
953 const struct argp_state
*state
;
956 /* If a user doc filter should be applied to DOC, do so. */
958 filter_doc (const char *doc
, int key
, const struct argp
*argp
,
959 const struct argp_state
*state
)
961 if (argp
->help_filter
)
962 /* We must apply a user filter to this output. */
964 void *input
= __argp_input (argp
, state
);
965 return (*argp
->help_filter
) (key
, doc
, input
);
972 /* Prints STR as a header line, with the margin lines set appropiately, and
973 notes the fact that groups should be separated with a blank line. ARGP is
974 the argp that should dictate any user doc filtering to take place. Note
975 that the previous wrap margin isn't restored, but the left margin is reset
978 print_header (const char *str
, const struct argp
*argp
,
979 struct pentry_state
*pest
)
981 const char *tstr
= dgettext (argp
->argp_domain
, str
);
982 const char *fstr
= filter_doc (tstr
, ARGP_KEY_HELP_HEADER
, argp
, pest
->state
);
988 if (pest
->hhstate
->prev_entry
)
989 /* Precede with a blank line. */
990 __argp_fmtstream_putc (pest
->stream
, '\n');
991 indent_to (pest
->stream
, uparams
.header_col
);
992 __argp_fmtstream_set_lmargin (pest
->stream
, uparams
.header_col
);
993 __argp_fmtstream_set_wmargin (pest
->stream
, uparams
.header_col
);
994 __argp_fmtstream_puts (pest
->stream
, fstr
);
995 __argp_fmtstream_set_lmargin (pest
->stream
, 0);
996 __argp_fmtstream_putc (pest
->stream
, '\n');
999 pest
->hhstate
->sep_groups
= 1; /* Separate subsequent groups. */
1003 free ((char *) fstr
);
1006 /* Inserts a comma if this isn't the first item on the line, and then makes
1007 sure we're at least to column COL. If this *is* the first item on a line,
1008 prints any pending whitespace/headers that should precede this line. Also
1011 comma (unsigned col
, struct pentry_state
*pest
)
1015 const struct hol_entry
*pe
= pest
->hhstate
->prev_entry
;
1016 const struct hol_cluster
*cl
= pest
->entry
->cluster
;
1018 if (pest
->hhstate
->sep_groups
&& pe
&& pest
->entry
->group
!= pe
->group
)
1019 __argp_fmtstream_putc (pest
->stream
, '\n');
1021 if (cl
&& cl
->header
&& *cl
->header
1023 || (pe
->cluster
!= cl
1024 && !hol_cluster_is_child (pe
->cluster
, cl
))))
1025 /* If we're changing clusters, then this must be the start of the
1026 ENTRY's cluster unless that is an ancestor of the previous one
1027 (in which case we had just popped into a sub-cluster for a bit).
1028 If so, then print the cluster's header line. */
1030 int old_wm
= __argp_fmtstream_wmargin (pest
->stream
);
1031 print_header (cl
->header
, cl
->argp
, pest
);
1032 __argp_fmtstream_set_wmargin (pest
->stream
, old_wm
);
1038 __argp_fmtstream_puts (pest
->stream
, ", ");
1040 indent_to (pest
->stream
, col
);
1043 /* Print help for ENTRY to STREAM. */
1045 hol_entry_help (struct hol_entry
*entry
, const struct argp_state
*state
,
1046 argp_fmtstream_t stream
, struct hol_help_state
*hhstate
)
1049 const struct argp_option
*real
= entry
->opt
, *opt
;
1050 char *so
= entry
->short_options
;
1051 int have_long_opt
= 0; /* We have any long options. */
1052 /* Saved margins. */
1053 int old_lm
= __argp_fmtstream_set_lmargin (stream
, 0);
1054 int old_wm
= __argp_fmtstream_wmargin (stream
);
1055 /* PEST is a state block holding some of our variables that we'd like to
1056 share with helper functions. */
1057 struct pentry_state pest
= { entry
, stream
, hhstate
, 1, state
};
1060 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1061 if (opt
->name
&& ovisible (opt
))
1067 /* First emit short options. */
1068 __argp_fmtstream_set_wmargin (stream
, uparams
.short_opt_col
); /* For truly bizarre cases. */
1069 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1070 if (oshort (opt
) && opt
->key
== *so
)
1071 /* OPT has a valid (non shadowed) short option. */
1075 comma (uparams
.short_opt_col
, &pest
);
1076 __argp_fmtstream_putc (stream
, '-');
1077 __argp_fmtstream_putc (stream
, *so
);
1078 if (!have_long_opt
|| uparams
.dup_args
)
1079 arg (real
, " %s", "[%s]", state
->root_argp
->argp_domain
, stream
);
1081 hhstate
->suppressed_dup_arg
= 1;
1086 /* Now, long options. */
1088 /* A `documentation' option. */
1090 __argp_fmtstream_set_wmargin (stream
, uparams
.doc_opt_col
);
1091 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1092 if (opt
->name
&& ovisible (opt
))
1094 comma (uparams
.doc_opt_col
, &pest
);
1095 /* Calling gettext here isn't quite right, since sorting will
1096 have been done on the original; but documentation options
1097 should be pretty rare anyway... */
1098 __argp_fmtstream_puts (stream
,
1099 dgettext (state
->root_argp
->argp_domain
,
1104 /* A real long option. */
1106 int first_long_opt
= 1;
1108 __argp_fmtstream_set_wmargin (stream
, uparams
.long_opt_col
);
1109 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1110 if (opt
->name
&& ovisible (opt
))
1112 comma (uparams
.long_opt_col
, &pest
);
1113 __argp_fmtstream_printf (stream
, "--%s", opt
->name
);
1114 if (first_long_opt
|| uparams
.dup_args
)
1115 arg (real
, "=%s", "[=%s]", state
->root_argp
->argp_domain
,
1118 hhstate
->suppressed_dup_arg
= 1;
1122 /* Next, documentation strings. */
1123 __argp_fmtstream_set_lmargin (stream
, 0);
1127 /* Didn't print any switches, what's up? */
1128 if (!oshort (real
) && !real
->name
)
1129 /* This is a group header, print it nicely. */
1130 print_header (real
->doc
, entry
->argp
, &pest
);
1132 /* Just a totally shadowed option or null header; print nothing. */
1133 goto cleanup
; /* Just return, after cleaning up. */
1137 const char *tstr
= real
->doc
? dgettext (state
->root_argp
->argp_domain
,
1139 const char *fstr
= filter_doc (tstr
, real
->key
, entry
->argp
, state
);
1142 unsigned int col
= __argp_fmtstream_point (stream
);
1144 __argp_fmtstream_set_lmargin (stream
, uparams
.opt_doc_col
);
1145 __argp_fmtstream_set_wmargin (stream
, uparams
.opt_doc_col
);
1147 if (col
> (unsigned int) (uparams
.opt_doc_col
+ 3))
1148 __argp_fmtstream_putc (stream
, '\n');
1149 else if (col
>= (unsigned int) uparams
.opt_doc_col
)
1150 __argp_fmtstream_puts (stream
, " ");
1152 indent_to (stream
, uparams
.opt_doc_col
);
1154 __argp_fmtstream_puts (stream
, fstr
);
1156 if (fstr
&& fstr
!= tstr
)
1157 free ((char *) fstr
);
1159 /* Reset the left margin. */
1160 __argp_fmtstream_set_lmargin (stream
, 0);
1161 __argp_fmtstream_putc (stream
, '\n');
1164 hhstate
->prev_entry
= entry
;
1167 __argp_fmtstream_set_lmargin (stream
, old_lm
);
1168 __argp_fmtstream_set_wmargin (stream
, old_wm
);
1171 /* Output a long help message about the options in HOL to STREAM. */
1173 hol_help (struct hol
*hol
, const struct argp_state
*state
,
1174 argp_fmtstream_t stream
)
1177 struct hol_entry
*entry
;
1178 struct hol_help_state hhstate
= { 0, 0, 0 };
1180 for (entry
= hol
->entries
, num
= hol
->num_entries
; num
> 0; entry
++, num
--)
1181 hol_entry_help (entry
, state
, stream
, &hhstate
);
1183 if (hhstate
.suppressed_dup_arg
&& uparams
.dup_args_note
)
1185 const char *tstr
= dgettext (state
->root_argp
->argp_domain
, "\
1186 Mandatory or optional arguments to long options are also mandatory or \
1187 optional for any corresponding short options.");
1188 const char *fstr
= filter_doc (tstr
, ARGP_KEY_HELP_DUP_ARGS_NOTE
,
1189 state
? state
->root_argp
: 0, state
);
1192 __argp_fmtstream_putc (stream
, '\n');
1193 __argp_fmtstream_puts (stream
, fstr
);
1194 __argp_fmtstream_putc (stream
, '\n');
1196 if (fstr
&& fstr
!= tstr
)
1197 free ((char *) fstr
);
1201 /* Helper functions for hol_usage. */
1203 /* If OPT is a short option without an arg, append its key to the string
1204 pointer pointer to by COOKIE, and advance the pointer. */
1206 add_argless_short_opt (const struct argp_option
*opt
,
1207 const struct argp_option
*real
,
1208 const char *domain
, void *cookie
)
1210 char **snao_end
= cookie
;
1211 if (!(opt
->arg
|| real
->arg
)
1212 && !((opt
->flags
| real
->flags
) & OPTION_NO_USAGE
))
1213 *(*snao_end
)++ = opt
->key
;
1217 /* If OPT is a short option with an arg, output a usage entry for it to the
1218 stream pointed at by COOKIE. */
1220 usage_argful_short_opt (const struct argp_option
*opt
,
1221 const struct argp_option
*real
,
1222 const char *domain
, void *cookie
)
1224 argp_fmtstream_t stream
= cookie
;
1225 const char *arg
= opt
->arg
;
1226 int flags
= opt
->flags
| real
->flags
;
1231 if (arg
&& !(flags
& OPTION_NO_USAGE
))
1233 arg
= dgettext (domain
, arg
);
1235 if (flags
& OPTION_ARG_OPTIONAL
)
1236 __argp_fmtstream_printf (stream
, " [-%c[%s]]", opt
->key
, arg
);
1239 /* Manually do line wrapping so that it (probably) won't
1240 get wrapped at the embedded space. */
1241 space (stream
, 6 + strlen (arg
));
1242 __argp_fmtstream_printf (stream
, "[-%c %s]", opt
->key
, arg
);
1249 /* Output a usage entry for the long option opt to the stream pointed at by
1252 usage_long_opt (const struct argp_option
*opt
,
1253 const struct argp_option
*real
,
1254 const char *domain
, void *cookie
)
1256 argp_fmtstream_t stream
= cookie
;
1257 const char *arg
= opt
->arg
;
1258 int flags
= opt
->flags
| real
->flags
;
1263 if (! (flags
& OPTION_NO_USAGE
))
1267 arg
= dgettext (domain
, arg
);
1268 if (flags
& OPTION_ARG_OPTIONAL
)
1269 __argp_fmtstream_printf (stream
, " [--%s[=%s]]", opt
->name
, arg
);
1271 __argp_fmtstream_printf (stream
, " [--%s=%s]", opt
->name
, arg
);
1274 __argp_fmtstream_printf (stream
, " [--%s]", opt
->name
);
1280 /* Print a short usage description for the arguments in HOL to STREAM. */
1282 hol_usage (struct hol
*hol
, argp_fmtstream_t stream
)
1284 if (hol
->num_entries
> 0)
1287 struct hol_entry
*entry
;
1288 char *short_no_arg_opts
= alloca (strlen (hol
->short_options
) + 1);
1289 char *snao_end
= short_no_arg_opts
;
1291 /* First we put a list of short options without arguments. */
1292 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1294 ; entry
++, nentries
--)
1295 hol_entry_short_iterate (entry
, add_argless_short_opt
,
1296 entry
->argp
->argp_domain
, &snao_end
);
1297 if (snao_end
> short_no_arg_opts
)
1300 __argp_fmtstream_printf (stream
, " [-%s]", short_no_arg_opts
);
1303 /* Now a list of short options *with* arguments. */
1304 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1306 ; entry
++, nentries
--)
1307 hol_entry_short_iterate (entry
, usage_argful_short_opt
,
1308 entry
->argp
->argp_domain
, stream
);
1310 /* Finally, a list of long options (whew!). */
1311 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1313 ; entry
++, nentries
--)
1314 hol_entry_long_iterate (entry
, usage_long_opt
,
1315 entry
->argp
->argp_domain
, stream
);
1319 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1320 cluster in which ARGP's entries should be clustered, or 0. */
1322 argp_hol (const struct argp
*argp
, struct hol_cluster
*cluster
)
1324 const struct argp_child
*child
= argp
->children
;
1325 struct hol
*hol
= make_hol (argp
, cluster
);
1329 struct hol_cluster
*child_cluster
=
1330 ((child
->group
|| child
->header
)
1331 /* Put CHILD->argp within its own cluster. */
1332 ? hol_add_cluster (hol
, child
->group
, child
->header
,
1333 child
- argp
->children
, cluster
, argp
)
1334 /* Just merge it into the parent's cluster. */
1336 hol_append (hol
, argp_hol (child
->argp
, child_cluster
)) ;
1342 /* Calculate how many different levels with alternative args strings exist in
1345 argp_args_levels (const struct argp
*argp
)
1348 const struct argp_child
*child
= argp
->children
;
1350 if (argp
->args_doc
&& strchr (argp
->args_doc
, '\n'))
1355 levels
+= argp_args_levels ((child
++)->argp
);
1360 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1361 preceded by a space. LEVELS is a pointer to a byte vector the length
1362 returned by argp_args_levels; it should be initialized to zero, and
1363 updated by this routine for the next call if ADVANCE is true. True is
1364 returned as long as there are more patterns to output. */
1366 argp_args_usage (const struct argp
*argp
, const struct argp_state
*state
,
1367 char **levels
, int advance
, argp_fmtstream_t stream
)
1369 char *our_level
= *levels
;
1371 const struct argp_child
*child
= argp
->children
;
1372 const char *tdoc
= dgettext (argp
->argp_domain
, argp
->args_doc
), *nl
= 0;
1373 const char *fdoc
= filter_doc (tdoc
, ARGP_KEY_HELP_ARGS_DOC
, argp
, state
);
1377 const char *cp
= fdoc
;
1378 nl
= __strchrnul (cp
, '\n');
1380 /* This is a `multi-level' args doc; advance to the correct position
1381 as determined by our state in LEVELS, and update LEVELS. */
1385 for (i
= 0; i
< *our_level
; i
++)
1386 cp
= nl
+ 1, nl
= __strchrnul (cp
, '\n');
1390 /* Manually do line wrapping so that it (probably) won't get wrapped at
1391 any embedded spaces. */
1392 space (stream
, 1 + nl
- cp
);
1394 __argp_fmtstream_write (stream
, cp
, nl
- cp
);
1396 if (fdoc
&& fdoc
!= tdoc
)
1397 free ((char *)fdoc
); /* Free user's modified doc string. */
1401 advance
= !argp_args_usage ((child
++)->argp
, state
, levels
, advance
, stream
);
1403 if (advance
&& multiple
)
1405 /* Need to increment our level. */
1407 /* There's more we can do here. */
1410 advance
= 0; /* Our parent shouldn't advance also. */
1412 else if (*our_level
> 0)
1413 /* We had multiple levels, but used them up; reset to zero. */
1420 /* Print the documentation for ARGP to STREAM; if POST is false, then
1421 everything preceeding a `\v' character in the documentation strings (or
1422 the whole string, for those with none) is printed, otherwise, everything
1423 following the `\v' character (nothing for strings without). Each separate
1424 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1425 then the first is as well. If FIRST_ONLY is true, only the first
1426 occurrence is output. Returns true if anything was output. */
1428 argp_doc (const struct argp
*argp
, const struct argp_state
*state
,
1429 int post
, int pre_blank
, int first_only
,
1430 argp_fmtstream_t stream
)
1433 const char *inp_text
;
1436 size_t inp_text_limit
= 0;
1437 const char *doc
= dgettext (argp
->argp_domain
, argp
->doc
);
1438 const struct argp_child
*child
= argp
->children
;
1442 char *vt
= strchr (doc
, '\v');
1443 inp_text
= post
? (vt
? vt
+ 1 : 0) : doc
;
1444 inp_text_limit
= (!post
&& vt
) ? (vt
- doc
) : 0;
1449 if (argp
->help_filter
)
1450 /* We have to filter the doc strings. */
1453 /* Copy INP_TEXT so that it's nul-terminated. */
1454 inp_text
= __strndup (inp_text
, inp_text_limit
);
1455 input
= __argp_input (argp
, state
);
1457 (*argp
->help_filter
) (post
1458 ? ARGP_KEY_HELP_POST_DOC
1459 : ARGP_KEY_HELP_PRE_DOC
,
1463 text
= (const char *) inp_text
;
1468 __argp_fmtstream_putc (stream
, '\n');
1470 if (text
== inp_text
&& inp_text_limit
)
1471 __argp_fmtstream_write (stream
, inp_text
, inp_text_limit
);
1473 __argp_fmtstream_puts (stream
, text
);
1475 if (__argp_fmtstream_point (stream
) > __argp_fmtstream_lmargin (stream
))
1476 __argp_fmtstream_putc (stream
, '\n');
1481 if (text
&& text
!= inp_text
)
1482 free ((char *) text
); /* Free TEXT returned from the help filter. */
1483 if (inp_text
&& inp_text_limit
&& argp
->help_filter
)
1484 free ((char *) inp_text
); /* We copied INP_TEXT, so free it now. */
1486 if (post
&& argp
->help_filter
)
1487 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1489 text
= (*argp
->help_filter
) (ARGP_KEY_HELP_EXTRA
, 0, input
);
1492 if (anything
|| pre_blank
)
1493 __argp_fmtstream_putc (stream
, '\n');
1494 __argp_fmtstream_puts (stream
, text
);
1495 free ((char *) text
);
1496 if (__argp_fmtstream_point (stream
)
1497 > __argp_fmtstream_lmargin (stream
))
1498 __argp_fmtstream_putc (stream
, '\n');
1504 while (child
->argp
&& !(first_only
&& anything
))
1506 argp_doc ((child
++)->argp
, state
,
1507 post
, anything
|| pre_blank
, first_only
,
1513 /* Output a usage message for ARGP to STREAM. If called from
1514 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1515 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1518 _help (const struct argp
*argp
, const struct argp_state
*state
, FILE *stream
,
1519 unsigned flags
, char *name
)
1521 int anything
= 0; /* Whether we've output anything. */
1522 struct hol
*hol
= 0;
1523 argp_fmtstream_t fs
;
1528 __flockfile (stream
);
1530 if (! uparams
.valid
)
1531 fill_in_uparams (state
);
1533 fs
= __argp_make_fmtstream (stream
, 0, uparams
.rmargin
, 0);
1536 __funlockfile (stream
);
1540 if (flags
& (ARGP_HELP_USAGE
| ARGP_HELP_SHORT_USAGE
| ARGP_HELP_LONG
))
1542 hol
= argp_hol (argp
, 0);
1544 /* If present, these options always come last. */
1545 hol_set_group (hol
, "help", -1);
1546 hol_set_group (hol
, "version", -1);
1551 if (flags
& (ARGP_HELP_USAGE
| ARGP_HELP_SHORT_USAGE
))
1552 /* Print a short `Usage:' message. */
1554 int first_pattern
= 1, more_patterns
;
1555 size_t num_pattern_levels
= argp_args_levels (argp
);
1556 char *pattern_levels
= alloca (num_pattern_levels
);
1558 memset (pattern_levels
, 0, num_pattern_levels
);
1563 int old_wm
= __argp_fmtstream_set_wmargin (fs
, uparams
.usage_indent
);
1564 char *levels
= pattern_levels
;
1567 __argp_fmtstream_printf (fs
, "%s %s",
1568 dgettext (argp
->argp_domain
, "Usage:"),
1571 __argp_fmtstream_printf (fs
, "%s %s",
1572 dgettext (argp
->argp_domain
, " or: "),
1575 /* We set the lmargin as well as the wmargin, because hol_usage
1576 manually wraps options with newline to avoid annoying breaks. */
1577 old_lm
= __argp_fmtstream_set_lmargin (fs
, uparams
.usage_indent
);
1579 if (flags
& ARGP_HELP_SHORT_USAGE
)
1580 /* Just show where the options go. */
1582 if (hol
->num_entries
> 0)
1583 __argp_fmtstream_puts (fs
, dgettext (argp
->argp_domain
,
1587 /* Actually print the options. */
1589 hol_usage (hol
, fs
);
1590 flags
|= ARGP_HELP_SHORT_USAGE
; /* But only do so once. */
1593 more_patterns
= argp_args_usage (argp
, state
, &levels
, 1, fs
);
1595 __argp_fmtstream_set_wmargin (fs
, old_wm
);
1596 __argp_fmtstream_set_lmargin (fs
, old_lm
);
1598 __argp_fmtstream_putc (fs
, '\n');
1603 while (more_patterns
);
1606 if (flags
& ARGP_HELP_PRE_DOC
)
1607 anything
|= argp_doc (argp
, state
, 0, 0, 1, fs
);
1609 if (flags
& ARGP_HELP_SEE
)
1611 __argp_fmtstream_printf (fs
, dgettext (argp
->argp_domain
, "\
1612 Try `%s --help' or `%s --usage' for more information.\n"),
1617 if (flags
& ARGP_HELP_LONG
)
1618 /* Print a long, detailed help message. */
1620 /* Print info about all the options. */
1621 if (hol
->num_entries
> 0)
1624 __argp_fmtstream_putc (fs
, '\n');
1625 hol_help (hol
, state
, fs
);
1630 if (flags
& ARGP_HELP_POST_DOC
)
1631 /* Print any documentation strings at the end. */
1632 anything
|= argp_doc (argp
, state
, 1, anything
, 0, fs
);
1634 if ((flags
& ARGP_HELP_BUG_ADDR
) && argp_program_bug_address
)
1637 __argp_fmtstream_putc (fs
, '\n');
1638 __argp_fmtstream_printf (fs
, dgettext (argp
->argp_domain
,
1639 "Report bugs to %s.\n"),
1640 argp_program_bug_address
);
1644 __funlockfile (stream
);
1649 __argp_fmtstream_free (fs
);
1652 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1653 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1654 void __argp_help (const struct argp
*argp
, FILE *stream
,
1655 unsigned flags
, char *name
)
1657 _help (argp
, 0, stream
, flags
, name
);
1660 weak_alias (__argp_help
, argp_help
)
1663 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1664 from the set ARGP_HELP_*. */
1666 __argp_state_help (const struct argp_state
*state
, FILE *stream
, unsigned flags
)
1668 if ((!state
|| ! (state
->flags
& ARGP_NO_ERRS
)) && stream
)
1670 if (state
&& (state
->flags
& ARGP_LONG_ONLY
))
1671 flags
|= ARGP_HELP_LONG_ONLY
;
1673 _help (state
? state
->root_argp
: 0, state
, stream
, flags
,
1674 state
? state
->name
: program_invocation_short_name
);
1676 if (!state
|| ! (state
->flags
& ARGP_NO_EXIT
))
1678 if (flags
& ARGP_HELP_EXIT_ERR
)
1679 exit (argp_err_exit_status
);
1680 if (flags
& ARGP_HELP_EXIT_OK
)
1686 weak_alias (__argp_state_help
, argp_state_help
)
1689 /* If appropriate, print the printf string FMT and following args, preceded
1690 by the program name and `:', to stderr, and followed by a `Try ... --help'
1691 message, then exit (1). */
1693 __argp_error (const struct argp_state
*state
, const char *fmt
, ...)
1695 if (!state
|| !(state
->flags
& ARGP_NO_ERRS
))
1697 FILE *stream
= state
? state
->err_stream
: stderr
;
1703 __flockfile (stream
);
1705 fputs_unlocked (state
? state
->name
: program_invocation_short_name
,
1707 putc_unlocked (':', stream
);
1708 putc_unlocked (' ', stream
);
1711 vfprintf (stream
, fmt
, ap
);
1714 putc_unlocked ('\n', stream
);
1716 __argp_state_help (state
, stream
, ARGP_HELP_STD_ERR
);
1718 __funlockfile (stream
);
1723 weak_alias (__argp_error
, argp_error
)
1726 /* Similar to the standard gnu error-reporting function error(), but will
1727 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1728 to STATE->err_stream. This is useful for argument parsing code that is
1729 shared between program startup (when exiting is desired) and runtime
1730 option parsing (when typically an error code is returned instead). The
1731 difference between this function and argp_error is that the latter is for
1732 *parsing errors*, and the former is for other problems that occur during
1733 parsing but don't reflect a (syntactic) problem with the input. */
1735 __argp_failure (const struct argp_state
*state
, int status
, int errnum
,
1736 const char *fmt
, ...)
1738 if (!state
|| !(state
->flags
& ARGP_NO_ERRS
))
1740 FILE *stream
= state
? state
->err_stream
: stderr
;
1744 __flockfile (stream
);
1746 fputs_unlocked (state
? state
->name
: program_invocation_short_name
,
1753 putc_unlocked (':', stream
);
1754 putc_unlocked (' ', stream
);
1757 vfprintf (stream
, fmt
, ap
);
1763 putc_unlocked (':', stream
);
1764 putc_unlocked (' ', stream
);
1765 fputs (strerror (errnum
), stream
);
1768 putc_unlocked ('\n', stream
);
1770 __funlockfile (stream
);
1772 if (status
&& (!state
|| !(state
->flags
& ARGP_NO_EXIT
)))
1778 weak_alias (__argp_failure
, argp_failure
)