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 Library General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 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 Library General Public License for more details.
16 You should have received a copy of the GNU Library General Public
17 License along with the GNU C Library; see the file COPYING.LIB. If not,
18 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
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
61 # define dgettext(domain, msgid) (msgid)
66 #include "argp-fmtstream.h"
67 #include "argp-namefrob.h"
69 /* User-selectable (using an environment variable) formatting parameters.
71 These may be specified in an environment variable called `ARGP_HELP_FMT',
72 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
73 Where VALn must be a positive integer. The list of variables is in the
74 UPARAM_NAMES vector, below. */
76 /* Default parameters. */
77 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
78 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
79 #define SHORT_OPT_COL 2 /* column in which short options start */
80 #define LONG_OPT_COL 6 /* column in which long options start */
81 #define DOC_OPT_COL 2 /* column in which doc options start */
82 #define OPT_DOC_COL 29 /* column in which option text starts */
83 #define HEADER_COL 1 /* column in which group headers are printed */
84 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
85 #define RMARGIN 79 /* right margin used for wrapping */
87 /* User-selectable (using an environment variable) formatting parameters.
88 They must all be of type `int' for the parsing code to work. */
91 /* If true, arguments for an option are shown with both short and long
92 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
93 If false, then if an option has both, the argument is only shown with
94 the long one, e.g., `-x, --longx=ARG', and a message indicating that
95 this really means both is printed below the options. */
98 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
99 been suppressed, an explanatory message should be printed. */
102 /* Various output columns. */
111 int valid
; /* True when the values in here are valid. */
114 /* This is a global variable, as user options are only ever read once. */
115 static struct uparams uparams
= {
116 DUP_ARGS
, DUP_ARGS_NOTE
,
117 SHORT_OPT_COL
, LONG_OPT_COL
, DOC_OPT_COL
, OPT_DOC_COL
, HEADER_COL
,
118 USAGE_INDENT
, RMARGIN
,
122 /* A particular uparam, and what the user name is. */
125 const char *name
; /* User name. */
126 int is_bool
; /* Whether it's `boolean'. */
127 size_t uparams_offs
; /* Location of the (int) field in UPARAMS. */
130 /* The name-field mappings we know about. */
131 static const struct uparam_name uparam_names
[] =
133 { "dup-args", 1, offsetof (struct uparams
, dup_args
) },
134 { "dup-args-note", 1, offsetof (struct uparams
, dup_args_note
) },
135 { "short-opt-col", 0, offsetof (struct uparams
, short_opt_col
) },
136 { "long-opt-col", 0, offsetof (struct uparams
, long_opt_col
) },
137 { "doc-opt-col", 0, offsetof (struct uparams
, doc_opt_col
) },
138 { "opt-doc-col", 0, offsetof (struct uparams
, opt_doc_col
) },
139 { "header-col", 0, offsetof (struct uparams
, header_col
) },
140 { "usage-indent", 0, offsetof (struct uparams
, usage_indent
) },
141 { "rmargin", 0, offsetof (struct uparams
, rmargin
) },
145 /* Read user options from the environment, and fill in UPARAMS appropiately. */
147 fill_in_uparams (const struct argp_state
*state
)
149 const char *var
= getenv ("ARGP_HELP_FMT");
151 #define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
162 const struct uparam_name
*un
;
163 int unspec
= 0, val
= 0;
164 const char *arg
= var
;
166 while (isalnum (*arg
) || *arg
== '-' || *arg
== '_')
172 if (*arg
== '\0' || *arg
== ',')
174 else if (*arg
== '=')
182 if (var
[0] == 'n' && var
[1] == 'o' && var
[2] == '-')
191 else if (isdigit (*arg
))
194 while (isdigit (*arg
))
199 for (un
= uparam_names
; un
->name
; un
++)
200 if (strlen (un
->name
) == var_len
201 && strncmp (var
, un
->name
, var_len
) == 0)
203 if (unspec
&& !un
->is_bool
)
204 __argp_failure (state
, 0, 0,
205 dgettext (state
->root_argp
->argp_domain
, "\
206 %.*s: ARGP_HELP_FMT parameter requires a value"),
209 *(int *)((char *)&uparams
+ un
->uparams_offs
) = val
;
213 __argp_failure (state
, 0, 0,
214 dgettext (state
->root_argp
->argp_domain
, "\
215 %.*s: Unknown ARGP_HELP_FMT parameter"),
224 __argp_failure (state
, 0, 0,
225 dgettext (state
->root_argp
->argp_domain
,
226 "Garbage in ARGP_HELP_FMT: %s"), var
);
232 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
233 whether OPT is displayed or used in sorting, not option shadowing. */
234 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
236 /* Returns true if OPT is an alias for an earlier option. */
237 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
239 /* Returns true if OPT is an documentation-only entry. */
240 #define odoc(opt) ((opt)->flags & OPTION_DOC)
242 /* Returns true if OPT is the end-of-list marker for a list of options. */
243 #define oend(opt) __option_is_end (opt)
245 /* Returns true if OPT has a short option. */
246 #define oshort(opt) __option_is_short (opt)
249 The help format for a particular option is like:
251 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
253 Where ARG will be omitted if there's no argument, for this option, or
254 will be surrounded by "[" and "]" appropiately if the argument is
255 optional. The documentation string is word-wrapped appropiately, and if
256 the list of options is long enough, it will be started on a separate line.
257 If there are no short options for a given option, the first long option is
258 indented slighly in a way that's supposed to make most long options appear
259 to be in a separate column.
261 For example, the following output (from ps):
263 -p PID, --pid=PID List the process PID
264 --pgrp=PGRP List processes in the process group PGRP
265 -P, -x, --no-parent Include processes without parents
266 -Q, --all-fields Don't elide unusable fields (normally if there's
267 some reason ps can't print a field for any
268 process, it's removed from the output entirely)
269 -r, --reverse, --gratuitously-long-reverse-option
270 Reverse the order of any sort
271 --session[=SID] Add the processes from the session SID (which
272 defaults to the sid of the current process)
274 Here are some more options:
275 -f ZOT, --foonly=ZOT Glork a foonly
276 -z, --zaza Snit a zar
278 -?, --help Give this help list
279 --usage Give a short usage message
280 -V, --version Print program version
282 The struct argp_option array for the above could look like:
285 {"pid", 'p', "PID", 0, "List the process PID"},
286 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
287 {"no-parent", 'P', 0, 0, "Include processes without parents"},
288 {0, 'x', 0, OPTION_ALIAS},
289 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
290 " if there's some reason ps can't"
291 " print a field for any process, it's"
292 " removed from the output entirely)" },
293 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
294 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
295 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
296 "Add the processes from the session"
297 " SID (which defaults to the sid of"
298 " the current process)" },
300 {0,0,0,0, "Here are some more options:"},
301 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
302 {"zaza", 'z', 0, 0, "Snit a zar"},
307 Note that the last three options are automatically supplied by argp_parse,
308 unless you tell it not to with ARGP_NO_HELP.
312 /* Returns true if CH occurs between BEG and END. */
314 find_char (char ch
, char *beg
, char *end
)
324 struct hol_cluster
; /* fwd decl */
329 const struct argp_option
*opt
;
330 /* Number of options (including aliases). */
333 /* A pointers into the HOL's short_options field, to the first short option
334 letter for this entry. The order of the characters following this point
335 corresponds to the order of options pointed to by OPT, and there are at
336 most NUM. A short option recorded in a option following OPT is only
337 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
338 probably been shadowed by some other entry). */
341 /* Entries are sorted by their group first, in the order:
342 1, 2, ..., n, 0, -m, ..., -2, -1
343 and then alphabetically within each group. The default is 0. */
346 /* The cluster of options this entry belongs to, or 0 if none. */
347 struct hol_cluster
*cluster
;
349 /* The argp from which this option came. */
350 const struct argp
*argp
;
353 /* A cluster of entries to reflect the argp tree structure. */
356 /* A descriptive header printed before options in this cluster. */
359 /* Used to order clusters within the same group with the same parent,
360 according to the order in which they occurred in the parent argp's child
364 /* How to sort this cluster with respect to options and other clusters at the
365 same depth (clusters always follow options in the same group). */
368 /* The cluster to which this cluster belongs, or 0 if it's at the base
370 struct hol_cluster
*parent
;
372 /* The argp from which this cluster is (eventually) derived. */
373 const struct argp
*argp
;
375 /* The distance this cluster is from the root. */
378 /* Clusters in a given hol are kept in a linked list, to make freeing them
380 struct hol_cluster
*next
;
383 /* A list of options for help. */
386 /* An array of hol_entry's. */
387 struct hol_entry
*entries
;
388 /* The number of entries in this hol. If this field is zero, the others
390 unsigned num_entries
;
392 /* A string containing all short options in this HOL. Each entry contains
393 pointers into this string, so the order can't be messed with blindly. */
396 /* Clusters of entries in this hol. */
397 struct hol_cluster
*clusters
;
400 /* Create a struct hol from the options in ARGP. CLUSTER is the
401 hol_cluster in which these entries occur, or 0, if at the root. */
403 make_hol (const struct argp
*argp
, struct hol_cluster
*cluster
)
406 const struct argp_option
*o
;
407 const struct argp_option
*opts
= argp
->options
;
408 struct hol_entry
*entry
;
409 unsigned num_short_options
= 0;
410 struct hol
*hol
= malloc (sizeof (struct hol
));
414 hol
->num_entries
= 0;
421 /* The first option must not be an alias. */
422 assert (! oalias (opts
));
424 /* Calculate the space needed. */
425 for (o
= opts
; ! oend (o
); o
++)
430 num_short_options
++; /* This is an upper bound. */
433 hol
->entries
= malloc (sizeof (struct hol_entry
) * hol
->num_entries
);
434 hol
->short_options
= malloc (num_short_options
+ 1);
436 assert (hol
->entries
&& hol
->short_options
);
438 /* Fill in the entries. */
439 so
= hol
->short_options
;
440 for (o
= opts
, entry
= hol
->entries
; ! oend (o
); entry
++)
444 entry
->short_options
= so
;
445 entry
->group
= cur_group
=
448 : ((!o
->name
&& !o
->key
)
451 entry
->cluster
= cluster
;
457 if (oshort (o
) && ! find_char (o
->key
, hol
->short_options
, so
))
458 /* O has a valid short option which hasn't already been used.*/
462 while (! oend (o
) && oalias (o
));
464 *so
= '\0'; /* null terminated so we can find the length */
470 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
471 associated argp child list entry), INDEX, and PARENT, and return a pointer
472 to it. ARGP is the argp that this cluster results from. */
473 static struct hol_cluster
*
474 hol_add_cluster (struct hol
*hol
, int group
, const char *header
, int index
,
475 struct hol_cluster
*parent
, const struct argp
*argp
)
477 struct hol_cluster
*cl
= malloc (sizeof (struct hol_cluster
));
486 cl
->depth
= parent
? parent
->depth
+ 1 : 0;
488 cl
->next
= hol
->clusters
;
494 /* Free HOL and any resources it uses. */
496 hol_free (struct hol
*hol
)
498 struct hol_cluster
*cl
= hol
->clusters
;
502 struct hol_cluster
*next
= cl
->next
;
507 if (hol
->num_entries
> 0)
510 free (hol
->short_options
);
517 hol_entry_short_iterate (const struct hol_entry
*entry
,
518 int (*func
)(const struct argp_option
*opt
,
519 const struct argp_option
*real
,
520 const char *domain
, void *cookie
),
521 const char *domain
, void *cookie
)
525 const struct argp_option
*opt
, *real
= entry
->opt
;
526 char *so
= entry
->short_options
;
528 for (opt
= real
, nopts
= entry
->num
; nopts
> 0 && !val
; opt
++, nopts
--)
529 if (oshort (opt
) && *so
== opt
->key
)
534 val
= (*func
)(opt
, real
, domain
, cookie
);
542 hol_entry_long_iterate (const struct hol_entry
*entry
,
543 int (*func
)(const struct argp_option
*opt
,
544 const struct argp_option
*real
,
545 const char *domain
, void *cookie
),
546 const char *domain
, void *cookie
)
550 const struct argp_option
*opt
, *real
= entry
->opt
;
552 for (opt
= real
, nopts
= entry
->num
; nopts
> 0 && !val
; opt
++, nopts
--)
558 val
= (*func
)(opt
, real
, domain
, cookie
);
564 /* Iterator that returns true for the first short option. */
566 until_short (const struct argp_option
*opt
, const struct argp_option
*real
,
567 const char *domain
, void *cookie
)
569 return oshort (opt
) ? opt
->key
: 0;
572 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
574 hol_entry_first_short (const struct hol_entry
*entry
)
576 return hol_entry_short_iterate (entry
, until_short
,
577 entry
->argp
->argp_domain
, 0);
580 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
582 hol_entry_first_long (const struct hol_entry
*entry
)
584 const struct argp_option
*opt
;
586 for (opt
= entry
->opt
, num
= entry
->num
; num
> 0; opt
++, num
--)
587 if (opt
->name
&& ovisible (opt
))
592 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
594 static struct hol_entry
*
595 hol_find_entry (struct hol
*hol
, const char *name
)
597 struct hol_entry
*entry
= hol
->entries
;
598 unsigned num_entries
= hol
->num_entries
;
600 while (num_entries
-- > 0)
602 const struct argp_option
*opt
= entry
->opt
;
603 unsigned num_opts
= entry
->num
;
605 while (num_opts
-- > 0)
606 if (opt
->name
&& ovisible (opt
) && strcmp (opt
->name
, name
) == 0)
617 /* If an entry with the long option NAME occurs in HOL, set it's special
618 sort position to GROUP. */
620 hol_set_group (struct hol
*hol
, const char *name
, int group
)
622 struct hol_entry
*entry
= hol_find_entry (hol
, name
);
624 entry
->group
= group
;
627 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
628 EQ is what to return if GROUP1 and GROUP2 are the same. */
630 group_cmp (int group1
, int group2
, int eq
)
632 if (group1
== group2
)
634 else if ((group1
< 0 && group2
< 0) || (group1
>= 0 && group2
>= 0))
635 return group1
- group2
;
637 return group2
- group1
;
640 /* Compare clusters CL1 & CL2 by the order that they should appear in
643 hol_cluster_cmp (const struct hol_cluster
*cl1
, const struct hol_cluster
*cl2
)
645 /* If one cluster is deeper than the other, use its ancestor at the same
646 level, so that finding the common ancestor is straightforward. */
647 while (cl1
->depth
< cl2
->depth
)
649 while (cl2
->depth
< cl1
->depth
)
652 /* Now reduce both clusters to their ancestors at the point where both have
653 a common parent; these can be directly compared. */
654 while (cl1
->parent
!= cl2
->parent
)
655 cl1
= cl1
->parent
, cl2
= cl2
->parent
;
657 return group_cmp (cl1
->group
, cl2
->group
, cl2
->index
- cl1
->index
);
660 /* Return the ancestor of CL that's just below the root (i.e., has a parent
662 static struct hol_cluster
*
663 hol_cluster_base (struct hol_cluster
*cl
)
670 /* Return true if CL1 is a child of CL2. */
672 hol_cluster_is_child (const struct hol_cluster
*cl1
,
673 const struct hol_cluster
*cl2
)
675 while (cl1
&& cl1
!= cl2
)
680 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
681 that should be used for comparisons, and returns true iff it should be
682 treated as a non-option. */
684 canon_doc_option (const char **name
)
687 /* Skip initial whitespace. */
688 while (isspace (**name
))
690 /* Decide whether this looks like an option (leading `-') or not. */
691 non_opt
= (**name
!= '-');
692 /* Skip until part of name used for sorting. */
693 while (**name
&& !isalnum (**name
))
698 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
701 hol_entry_cmp (const struct hol_entry
*entry1
,
702 const struct hol_entry
*entry2
)
704 /* The group numbers by which the entries should be ordered; if either is
705 in a cluster, then this is just the group within the cluster. */
706 int group1
= entry1
->group
, group2
= entry2
->group
;
708 if (entry1
->cluster
!= entry2
->cluster
)
710 /* The entries are not within the same cluster, so we can't compare them
711 directly, we have to use the appropiate clustering level too. */
712 if (! entry1
->cluster
)
713 /* ENTRY1 is at the `base level', not in a cluster, so we have to
714 compare it's group number with that of the base cluster in which
715 ENTRY2 resides. Note that if they're in the same group, the
716 clustered option always comes laster. */
717 return group_cmp (group1
, hol_cluster_base (entry2
->cluster
)->group
, -1);
718 else if (! entry2
->cluster
)
719 /* Likewise, but ENTRY2's not in a cluster. */
720 return group_cmp (hol_cluster_base (entry1
->cluster
)->group
, group2
, 1);
722 /* Both entries are in clusters, we can just compare the clusters. */
723 return hol_cluster_cmp (entry1
->cluster
, entry2
->cluster
);
725 else if (group1
== group2
)
726 /* The entries are both in the same cluster and group, so compare them
729 int short1
= hol_entry_first_short (entry1
);
730 int short2
= hol_entry_first_short (entry2
);
731 int doc1
= odoc (entry1
->opt
);
732 int doc2
= odoc (entry2
->opt
);
733 const char *long1
= hol_entry_first_long (entry1
);
734 const char *long2
= hol_entry_first_long (entry2
);
737 doc1
= canon_doc_option (&long1
);
739 doc2
= canon_doc_option (&long2
);
742 /* `documentation' options always follow normal options (or
743 documentation options that *look* like normal options). */
745 else if (!short1
&& !short2
&& long1
&& long2
)
746 /* Only long options. */
747 return __strcasecmp (long1
, long2
);
749 /* Compare short/short, long/short, short/long, using the first
750 character of long options. Entries without *any* valid
751 options (such as options with OPTION_HIDDEN set) will be put
752 first, but as they're not displayed, it doesn't matter where
755 char first1
= short1
? short1
: long1
? *long1
: 0;
756 char first2
= short2
? short2
: long2
? *long2
: 0;
758 int lower_cmp
= _tolower (first1
) - _tolower (first2
);
760 int lower_cmp
= tolower (first1
) - tolower (first2
);
762 /* Compare ignoring case, except when the options are both the
763 same letter, in which case lower-case always comes first. */
764 return lower_cmp
? lower_cmp
: first2
- first1
;
768 /* Within the same cluster, but not the same group, so just compare
770 return group_cmp (group1
, group2
, 0);
773 /* Version of hol_entry_cmp with correct signature for qsort. */
775 hol_entry_qcmp (const void *entry1_v
, const void *entry2_v
)
777 return hol_entry_cmp (entry1_v
, entry2_v
);
780 /* Sort HOL by group and alphabetically by option name (with short options
781 taking precedence over long). Since the sorting is for display purposes
782 only, the shadowing of options isn't effected. */
784 hol_sort (struct hol
*hol
)
786 if (hol
->num_entries
> 0)
787 qsort (hol
->entries
, hol
->num_entries
, sizeof (struct hol_entry
),
791 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
792 any in MORE with the same name. */
794 hol_append (struct hol
*hol
, struct hol
*more
)
796 struct hol_cluster
**cl_end
= &hol
->clusters
;
798 /* Steal MORE's cluster list, and add it to the end of HOL's. */
800 cl_end
= &(*cl_end
)->next
;
801 *cl_end
= more
->clusters
;
805 if (more
->num_entries
> 0)
807 if (hol
->num_entries
== 0)
809 hol
->num_entries
= more
->num_entries
;
810 hol
->entries
= more
->entries
;
811 hol
->short_options
= more
->short_options
;
812 more
->num_entries
= 0; /* Mark MORE's fields as invalid. */
815 /* Append the entries in MORE to those in HOL, taking care to only add
816 non-shadowed SHORT_OPTIONS values. */
821 unsigned num_entries
= hol
->num_entries
+ more
->num_entries
;
822 struct hol_entry
*entries
=
823 malloc (num_entries
* sizeof (struct hol_entry
));
824 unsigned hol_so_len
= strlen (hol
->short_options
);
825 char *short_options
=
826 malloc (hol_so_len
+ strlen (more
->short_options
) + 1);
828 __mempcpy (__mempcpy (entries
, hol
->entries
,
829 hol
->num_entries
* sizeof (struct hol_entry
)),
831 more
->num_entries
* sizeof (struct hol_entry
));
833 __mempcpy (short_options
, hol
->short_options
, hol_so_len
);
835 /* Fix up the short options pointers from HOL. */
836 for (e
= entries
, left
= hol
->num_entries
; left
> 0; e
++, left
--)
837 e
->short_options
+= (short_options
- hol
->short_options
);
839 /* Now add the short options from MORE, fixing up its entries
841 so
= short_options
+ hol_so_len
;
842 more_so
= more
->short_options
;
843 for (left
= more
->num_entries
; left
> 0; e
++, left
--)
846 const struct argp_option
*opt
;
848 e
->short_options
= so
;
850 for (opts_left
= e
->num
, opt
= e
->opt
; opts_left
; opt
++, opts_left
--)
853 if (oshort (opt
) && ch
== opt
->key
)
854 /* The next short option in MORE_SO, CH, is from OPT. */
856 if (! find_char (ch
, short_options
,
857 short_options
+ hol_so_len
))
858 /* The short option CH isn't shadowed by HOL's options,
859 so add it to the sum. */
869 free (hol
->short_options
);
871 hol
->entries
= entries
;
872 hol
->num_entries
= num_entries
;
873 hol
->short_options
= short_options
;
880 /* Inserts enough spaces to make sure STREAM is at column COL. */
882 indent_to (argp_fmtstream_t stream
, unsigned col
)
884 int needed
= col
- __argp_fmtstream_point (stream
);
886 __argp_fmtstream_putc (stream
, ' ');
889 /* Output to STREAM either a space, or a newline if there isn't room for at
890 least ENSURE characters before the right margin. */
892 space (argp_fmtstream_t stream
, size_t ensure
)
894 if (__argp_fmtstream_point (stream
) + ensure
895 >= __argp_fmtstream_rmargin (stream
))
896 __argp_fmtstream_putc (stream
, '\n');
898 __argp_fmtstream_putc (stream
, ' ');
901 /* If the option REAL has an argument, we print it in using the printf
902 format REQ_FMT or OPT_FMT depending on whether it's a required or
903 optional argument. */
905 arg (const struct argp_option
*real
, const char *req_fmt
, const char *opt_fmt
,
906 const char *domain
, argp_fmtstream_t stream
)
910 if (real
->flags
& OPTION_ARG_OPTIONAL
)
911 __argp_fmtstream_printf (stream
, opt_fmt
,
912 dgettext (domain
, real
->arg
));
914 __argp_fmtstream_printf (stream
, req_fmt
,
915 dgettext (domain
, real
->arg
));
919 /* Helper functions for hol_entry_help. */
921 /* State used during the execution of hol_help. */
922 struct hol_help_state
924 /* PREV_ENTRY should contain the previous entry printed, or 0. */
925 struct hol_entry
*prev_entry
;
927 /* If an entry is in a different group from the previous one, and SEP_GROUPS
928 is true, then a blank line will be printed before any output. */
931 /* True if a duplicate option argument was suppressed (only ever set if
932 UPARAMS.dup_args is false). */
933 int suppressed_dup_arg
;
936 /* Some state used while printing a help entry (used to communicate with
937 helper functions). See the doc for hol_entry_help for more info, as most
938 of the fields are copied from its arguments. */
941 const struct hol_entry
*entry
;
942 argp_fmtstream_t stream
;
943 struct hol_help_state
*hhstate
;
945 /* True if nothing's been printed so far. */
948 /* If non-zero, the state that was used to print this help. */
949 const struct argp_state
*state
;
952 /* If a user doc filter should be applied to DOC, do so. */
954 filter_doc (const char *doc
, int key
, const struct argp
*argp
,
955 const struct argp_state
*state
)
957 if (argp
->help_filter
)
958 /* We must apply a user filter to this output. */
960 void *input
= __argp_input (argp
, state
);
961 return (*argp
->help_filter
) (key
, doc
, input
);
968 /* Prints STR as a header line, with the margin lines set appropiately, and
969 notes the fact that groups should be separated with a blank line. ARGP is
970 the argp that should dictate any user doc filtering to take place. Note
971 that the previous wrap margin isn't restored, but the left margin is reset
974 print_header (const char *str
, const struct argp
*argp
,
975 struct pentry_state
*pest
)
977 const char *tstr
= dgettext (argp
->argp_domain
, str
);
978 const char *fstr
= filter_doc (tstr
, ARGP_KEY_HELP_HEADER
, argp
, pest
->state
);
984 if (pest
->hhstate
->prev_entry
)
985 /* Precede with a blank line. */
986 __argp_fmtstream_putc (pest
->stream
, '\n');
987 indent_to (pest
->stream
, uparams
.header_col
);
988 __argp_fmtstream_set_lmargin (pest
->stream
, uparams
.header_col
);
989 __argp_fmtstream_set_wmargin (pest
->stream
, uparams
.header_col
);
990 __argp_fmtstream_puts (pest
->stream
, fstr
);
991 __argp_fmtstream_set_lmargin (pest
->stream
, 0);
992 __argp_fmtstream_putc (pest
->stream
, '\n');
995 pest
->hhstate
->sep_groups
= 1; /* Separate subsequent groups. */
999 free ((char *) fstr
);
1002 /* Inserts a comma if this isn't the first item on the line, and then makes
1003 sure we're at least to column COL. If this *is* the first item on a line,
1004 prints any pending whitespace/headers that should precede this line. Also
1007 comma (unsigned col
, struct pentry_state
*pest
)
1011 const struct hol_entry
*pe
= pest
->hhstate
->prev_entry
;
1012 const struct hol_cluster
*cl
= pest
->entry
->cluster
;
1014 if (pest
->hhstate
->sep_groups
&& pe
&& pest
->entry
->group
!= pe
->group
)
1015 __argp_fmtstream_putc (pest
->stream
, '\n');
1017 if (cl
&& cl
->header
&& *cl
->header
1019 || (pe
->cluster
!= cl
1020 && !hol_cluster_is_child (pe
->cluster
, cl
))))
1021 /* If we're changing clusters, then this must be the start of the
1022 ENTRY's cluster unless that is an ancestor of the previous one
1023 (in which case we had just popped into a sub-cluster for a bit).
1024 If so, then print the cluster's header line. */
1026 int old_wm
= __argp_fmtstream_wmargin (pest
->stream
);
1027 print_header (cl
->header
, cl
->argp
, pest
);
1028 __argp_fmtstream_set_wmargin (pest
->stream
, old_wm
);
1034 __argp_fmtstream_puts (pest
->stream
, ", ");
1036 indent_to (pest
->stream
, col
);
1039 /* Print help for ENTRY to STREAM. */
1041 hol_entry_help (struct hol_entry
*entry
, const struct argp_state
*state
,
1042 argp_fmtstream_t stream
, struct hol_help_state
*hhstate
)
1045 const struct argp_option
*real
= entry
->opt
, *opt
;
1046 char *so
= entry
->short_options
;
1047 int have_long_opt
= 0; /* We have any long options. */
1048 /* Saved margins. */
1049 int old_lm
= __argp_fmtstream_set_lmargin (stream
, 0);
1050 int old_wm
= __argp_fmtstream_wmargin (stream
);
1051 /* PEST is a state block holding some of our variables that we'd like to
1052 share with helper functions. */
1053 struct pentry_state pest
= { entry
, stream
, hhstate
, 1, state
};
1056 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1057 if (opt
->name
&& ovisible (opt
))
1063 /* First emit short options. */
1064 __argp_fmtstream_set_wmargin (stream
, uparams
.short_opt_col
); /* For truly bizarre cases. */
1065 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1066 if (oshort (opt
) && opt
->key
== *so
)
1067 /* OPT has a valid (non shadowed) short option. */
1071 comma (uparams
.short_opt_col
, &pest
);
1072 __argp_fmtstream_putc (stream
, '-');
1073 __argp_fmtstream_putc (stream
, *so
);
1074 if (!have_long_opt
|| uparams
.dup_args
)
1075 arg (real
, " %s", "[%s]", state
->root_argp
->argp_domain
, stream
);
1077 hhstate
->suppressed_dup_arg
= 1;
1082 /* Now, long options. */
1084 /* A `documentation' option. */
1086 __argp_fmtstream_set_wmargin (stream
, uparams
.doc_opt_col
);
1087 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1088 if (opt
->name
&& ovisible (opt
))
1090 comma (uparams
.doc_opt_col
, &pest
);
1091 /* Calling gettext here isn't quite right, since sorting will
1092 have been done on the original; but documentation options
1093 should be pretty rare anyway... */
1094 __argp_fmtstream_puts (stream
,
1095 dgettext (state
->root_argp
->argp_domain
,
1100 /* A real long option. */
1102 int first_long_opt
= 1;
1104 __argp_fmtstream_set_wmargin (stream
, uparams
.long_opt_col
);
1105 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1106 if (opt
->name
&& ovisible (opt
))
1108 comma (uparams
.long_opt_col
, &pest
);
1109 __argp_fmtstream_printf (stream
, "--%s", opt
->name
);
1110 if (first_long_opt
|| uparams
.dup_args
)
1111 arg (real
, "=%s", "[=%s]", state
->root_argp
->argp_domain
,
1114 hhstate
->suppressed_dup_arg
= 1;
1118 /* Next, documentation strings. */
1119 __argp_fmtstream_set_lmargin (stream
, 0);
1123 /* Didn't print any switches, what's up? */
1124 if (!oshort (real
) && !real
->name
)
1125 /* This is a group header, print it nicely. */
1126 print_header (real
->doc
, entry
->argp
, &pest
);
1128 /* Just a totally shadowed option or null header; print nothing. */
1129 goto cleanup
; /* Just return, after cleaning up. */
1133 const char *tstr
= real
->doc
? dgettext (state
->root_argp
->argp_domain
,
1135 const char *fstr
= filter_doc (tstr
, real
->key
, entry
->argp
, state
);
1138 unsigned int col
= __argp_fmtstream_point (stream
);
1140 __argp_fmtstream_set_lmargin (stream
, uparams
.opt_doc_col
);
1141 __argp_fmtstream_set_wmargin (stream
, uparams
.opt_doc_col
);
1143 if (col
> (unsigned int) (uparams
.opt_doc_col
+ 3))
1144 __argp_fmtstream_putc (stream
, '\n');
1145 else if (col
>= (unsigned int) uparams
.opt_doc_col
)
1146 __argp_fmtstream_puts (stream
, " ");
1148 indent_to (stream
, uparams
.opt_doc_col
);
1150 __argp_fmtstream_puts (stream
, fstr
);
1152 if (fstr
&& fstr
!= tstr
)
1153 free ((char *) fstr
);
1155 /* Reset the left margin. */
1156 __argp_fmtstream_set_lmargin (stream
, 0);
1157 __argp_fmtstream_putc (stream
, '\n');
1160 hhstate
->prev_entry
= entry
;
1163 __argp_fmtstream_set_lmargin (stream
, old_lm
);
1164 __argp_fmtstream_set_wmargin (stream
, old_wm
);
1167 /* Output a long help message about the options in HOL to STREAM. */
1169 hol_help (struct hol
*hol
, const struct argp_state
*state
,
1170 argp_fmtstream_t stream
)
1173 struct hol_entry
*entry
;
1174 struct hol_help_state hhstate
= { 0, 0, 0 };
1176 for (entry
= hol
->entries
, num
= hol
->num_entries
; num
> 0; entry
++, num
--)
1177 hol_entry_help (entry
, state
, stream
, &hhstate
);
1179 if (hhstate
.suppressed_dup_arg
&& uparams
.dup_args_note
)
1181 const char *tstr
= dgettext (state
->root_argp
->argp_domain
, "\
1182 Mandatory or optional arguments to long options are also mandatory or \
1183 optional for any corresponding short options.");
1184 const char *fstr
= filter_doc (tstr
, ARGP_KEY_HELP_DUP_ARGS_NOTE
,
1185 state
? state
->root_argp
: 0, state
);
1188 __argp_fmtstream_putc (stream
, '\n');
1189 __argp_fmtstream_puts (stream
, fstr
);
1190 __argp_fmtstream_putc (stream
, '\n');
1192 if (fstr
&& fstr
!= tstr
)
1193 free ((char *) fstr
);
1197 /* Helper functions for hol_usage. */
1199 /* If OPT is a short option without an arg, append its key to the string
1200 pointer pointer to by COOKIE, and advance the pointer. */
1202 add_argless_short_opt (const struct argp_option
*opt
,
1203 const struct argp_option
*real
,
1204 const char *domain
, void *cookie
)
1206 char **snao_end
= cookie
;
1207 if (!(opt
->arg
|| real
->arg
)
1208 && !((opt
->flags
| real
->flags
) & OPTION_NO_USAGE
))
1209 *(*snao_end
)++ = opt
->key
;
1213 /* If OPT is a short option with an arg, output a usage entry for it to the
1214 stream pointed at by COOKIE. */
1216 usage_argful_short_opt (const struct argp_option
*opt
,
1217 const struct argp_option
*real
,
1218 const char *domain
, void *cookie
)
1220 argp_fmtstream_t stream
= cookie
;
1221 const char *arg
= opt
->arg
;
1222 int flags
= opt
->flags
| real
->flags
;
1227 if (arg
&& !(flags
& OPTION_NO_USAGE
))
1229 arg
= dgettext (domain
, arg
);
1231 if (flags
& OPTION_ARG_OPTIONAL
)
1232 __argp_fmtstream_printf (stream
, " [-%c[%s]]", opt
->key
, arg
);
1235 /* Manually do line wrapping so that it (probably) won't
1236 get wrapped at the embedded space. */
1237 space (stream
, 6 + strlen (arg
));
1238 __argp_fmtstream_printf (stream
, "[-%c %s]", opt
->key
, arg
);
1245 /* Output a usage entry for the long option opt to the stream pointed at by
1248 usage_long_opt (const struct argp_option
*opt
,
1249 const struct argp_option
*real
,
1250 const char *domain
, void *cookie
)
1252 argp_fmtstream_t stream
= cookie
;
1253 const char *arg
= opt
->arg
;
1254 int flags
= opt
->flags
| real
->flags
;
1259 if (! (flags
& OPTION_NO_USAGE
))
1263 arg
= dgettext (domain
, arg
);
1264 if (flags
& OPTION_ARG_OPTIONAL
)
1265 __argp_fmtstream_printf (stream
, " [--%s[=%s]]", opt
->name
, arg
);
1267 __argp_fmtstream_printf (stream
, " [--%s=%s]", opt
->name
, arg
);
1270 __argp_fmtstream_printf (stream
, " [--%s]", opt
->name
);
1276 /* Print a short usage description for the arguments in HOL to STREAM. */
1278 hol_usage (struct hol
*hol
, argp_fmtstream_t stream
)
1280 if (hol
->num_entries
> 0)
1283 struct hol_entry
*entry
;
1284 char *short_no_arg_opts
= alloca (strlen (hol
->short_options
) + 1);
1285 char *snao_end
= short_no_arg_opts
;
1287 /* First we put a list of short options without arguments. */
1288 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1290 ; entry
++, nentries
--)
1291 hol_entry_short_iterate (entry
, add_argless_short_opt
,
1292 entry
->argp
->argp_domain
, &snao_end
);
1293 if (snao_end
> short_no_arg_opts
)
1296 __argp_fmtstream_printf (stream
, " [-%s]", short_no_arg_opts
);
1299 /* Now a list of short options *with* arguments. */
1300 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1302 ; entry
++, nentries
--)
1303 hol_entry_short_iterate (entry
, usage_argful_short_opt
,
1304 entry
->argp
->argp_domain
, stream
);
1306 /* Finally, a list of long options (whew!). */
1307 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1309 ; entry
++, nentries
--)
1310 hol_entry_long_iterate (entry
, usage_long_opt
,
1311 entry
->argp
->argp_domain
, stream
);
1315 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1316 cluster in which ARGP's entries should be clustered, or 0. */
1318 argp_hol (const struct argp
*argp
, struct hol_cluster
*cluster
)
1320 const struct argp_child
*child
= argp
->children
;
1321 struct hol
*hol
= make_hol (argp
, cluster
);
1325 struct hol_cluster
*child_cluster
=
1326 ((child
->group
|| child
->header
)
1327 /* Put CHILD->argp within its own cluster. */
1328 ? hol_add_cluster (hol
, child
->group
, child
->header
,
1329 child
- argp
->children
, cluster
, argp
)
1330 /* Just merge it into the parent's cluster. */
1332 hol_append (hol
, argp_hol (child
->argp
, child_cluster
)) ;
1338 /* Calculate how many different levels with alternative args strings exist in
1341 argp_args_levels (const struct argp
*argp
)
1344 const struct argp_child
*child
= argp
->children
;
1346 if (argp
->args_doc
&& strchr (argp
->args_doc
, '\n'))
1351 levels
+= argp_args_levels ((child
++)->argp
);
1356 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1357 preceded by a space. LEVELS is a pointer to a byte vector the length
1358 returned by argp_args_levels; it should be initialized to zero, and
1359 updated by this routine for the next call if ADVANCE is true. True is
1360 returned as long as there are more patterns to output. */
1362 argp_args_usage (const struct argp
*argp
, const struct argp_state
*state
,
1363 char **levels
, int advance
, argp_fmtstream_t stream
)
1365 char *our_level
= *levels
;
1367 const struct argp_child
*child
= argp
->children
;
1368 const char *tdoc
= dgettext (argp
->argp_domain
, argp
->args_doc
), *nl
= 0;
1369 const char *fdoc
= filter_doc (tdoc
, ARGP_KEY_HELP_ARGS_DOC
, argp
, state
);
1373 const char *cp
= fdoc
;
1374 nl
= __strchrnul (cp
, '\n');
1376 /* This is a `multi-level' args doc; advance to the correct position
1377 as determined by our state in LEVELS, and update LEVELS. */
1381 for (i
= 0; i
< *our_level
; i
++)
1382 cp
= nl
+ 1, nl
= __strchrnul (cp
, '\n');
1386 /* Manually do line wrapping so that it (probably) won't get wrapped at
1387 any embedded spaces. */
1388 space (stream
, 1 + nl
- cp
);
1390 __argp_fmtstream_write (stream
, cp
, nl
- cp
);
1392 if (fdoc
&& fdoc
!= tdoc
)
1393 free ((char *)fdoc
); /* Free user's modified doc string. */
1397 advance
= !argp_args_usage ((child
++)->argp
, state
, levels
, advance
, stream
);
1399 if (advance
&& multiple
)
1401 /* Need to increment our level. */
1403 /* There's more we can do here. */
1406 advance
= 0; /* Our parent shouldn't advance also. */
1408 else if (*our_level
> 0)
1409 /* We had multiple levels, but used them up; reset to zero. */
1416 /* Print the documentation for ARGP to STREAM; if POST is false, then
1417 everything preceeding a `\v' character in the documentation strings (or
1418 the whole string, for those with none) is printed, otherwise, everything
1419 following the `\v' character (nothing for strings without). Each separate
1420 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1421 then the first is as well. If FIRST_ONLY is true, only the first
1422 occurrence is output. Returns true if anything was output. */
1424 argp_doc (const struct argp
*argp
, const struct argp_state
*state
,
1425 int post
, int pre_blank
, int first_only
,
1426 argp_fmtstream_t stream
)
1429 const char *inp_text
;
1432 size_t inp_text_limit
= 0;
1433 const char *doc
= dgettext (argp
->argp_domain
, argp
->doc
);
1434 const struct argp_child
*child
= argp
->children
;
1438 char *vt
= strchr (doc
, '\v');
1439 inp_text
= post
? (vt
? vt
+ 1 : 0) : doc
;
1440 inp_text_limit
= (!post
&& vt
) ? (vt
- doc
) : 0;
1445 if (argp
->help_filter
)
1446 /* We have to filter the doc strings. */
1449 /* Copy INP_TEXT so that it's nul-terminated. */
1450 inp_text
= __strndup (inp_text
, inp_text_limit
);
1451 input
= __argp_input (argp
, state
);
1453 (*argp
->help_filter
) (post
1454 ? ARGP_KEY_HELP_POST_DOC
1455 : ARGP_KEY_HELP_PRE_DOC
,
1459 text
= (const char *) inp_text
;
1464 __argp_fmtstream_putc (stream
, '\n');
1466 if (text
== inp_text
&& inp_text_limit
)
1467 __argp_fmtstream_write (stream
, inp_text
, inp_text_limit
);
1469 __argp_fmtstream_puts (stream
, text
);
1471 if (__argp_fmtstream_point (stream
) > __argp_fmtstream_lmargin (stream
))
1472 __argp_fmtstream_putc (stream
, '\n');
1477 if (text
&& text
!= inp_text
)
1478 free ((char *) text
); /* Free TEXT returned from the help filter. */
1479 if (inp_text
&& inp_text_limit
&& argp
->help_filter
)
1480 free ((char *) inp_text
); /* We copied INP_TEXT, so free it now. */
1482 if (post
&& argp
->help_filter
)
1483 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1485 text
= (*argp
->help_filter
) (ARGP_KEY_HELP_EXTRA
, 0, input
);
1488 if (anything
|| pre_blank
)
1489 __argp_fmtstream_putc (stream
, '\n');
1490 __argp_fmtstream_puts (stream
, text
);
1491 free ((char *) text
);
1492 if (__argp_fmtstream_point (stream
)
1493 > __argp_fmtstream_lmargin (stream
))
1494 __argp_fmtstream_putc (stream
, '\n');
1500 while (child
->argp
&& !(first_only
&& anything
))
1502 argp_doc ((child
++)->argp
, state
,
1503 post
, anything
|| pre_blank
, first_only
,
1509 /* Output a usage message for ARGP to STREAM. If called from
1510 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1511 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1514 _help (const struct argp
*argp
, const struct argp_state
*state
, FILE *stream
,
1515 unsigned flags
, char *name
)
1517 int anything
= 0; /* Whether we've output anything. */
1518 struct hol
*hol
= 0;
1519 argp_fmtstream_t fs
;
1524 __flockfile (stream
);
1526 if (! uparams
.valid
)
1527 fill_in_uparams (state
);
1529 fs
= __argp_make_fmtstream (stream
, 0, uparams
.rmargin
, 0);
1532 __funlockfile (stream
);
1536 if (flags
& (ARGP_HELP_USAGE
| ARGP_HELP_SHORT_USAGE
| ARGP_HELP_LONG
))
1538 hol
= argp_hol (argp
, 0);
1540 /* If present, these options always come last. */
1541 hol_set_group (hol
, "help", -1);
1542 hol_set_group (hol
, "version", -1);
1547 if (flags
& (ARGP_HELP_USAGE
| ARGP_HELP_SHORT_USAGE
))
1548 /* Print a short `Usage:' message. */
1550 int first_pattern
= 1, more_patterns
;
1551 size_t num_pattern_levels
= argp_args_levels (argp
);
1552 char *pattern_levels
= alloca (num_pattern_levels
);
1554 memset (pattern_levels
, 0, num_pattern_levels
);
1559 int old_wm
= __argp_fmtstream_set_wmargin (fs
, uparams
.usage_indent
);
1560 char *levels
= pattern_levels
;
1563 __argp_fmtstream_printf (fs
, "%s %s",
1564 dgettext (argp
->argp_domain
, "Usage:"),
1567 __argp_fmtstream_printf (fs
, "%s %s",
1568 dgettext (argp
->argp_domain
, " or: "),
1571 /* We set the lmargin as well as the wmargin, because hol_usage
1572 manually wraps options with newline to avoid annoying breaks. */
1573 old_lm
= __argp_fmtstream_set_lmargin (fs
, uparams
.usage_indent
);
1575 if (flags
& ARGP_HELP_SHORT_USAGE
)
1576 /* Just show where the options go. */
1578 if (hol
->num_entries
> 0)
1579 __argp_fmtstream_puts (fs
, dgettext (argp
->argp_domain
,
1583 /* Actually print the options. */
1585 hol_usage (hol
, fs
);
1586 flags
|= ARGP_HELP_SHORT_USAGE
; /* But only do so once. */
1589 more_patterns
= argp_args_usage (argp
, state
, &levels
, 1, fs
);
1591 __argp_fmtstream_set_wmargin (fs
, old_wm
);
1592 __argp_fmtstream_set_lmargin (fs
, old_lm
);
1594 __argp_fmtstream_putc (fs
, '\n');
1599 while (more_patterns
);
1602 if (flags
& ARGP_HELP_PRE_DOC
)
1603 anything
|= argp_doc (argp
, state
, 0, 0, 1, fs
);
1605 if (flags
& ARGP_HELP_SEE
)
1607 __argp_fmtstream_printf (fs
, dgettext (argp
->argp_domain
, "\
1608 Try `%s --help' or `%s --usage' for more information.\n"),
1613 if (flags
& ARGP_HELP_LONG
)
1614 /* Print a long, detailed help message. */
1616 /* Print info about all the options. */
1617 if (hol
->num_entries
> 0)
1620 __argp_fmtstream_putc (fs
, '\n');
1621 hol_help (hol
, state
, fs
);
1626 if (flags
& ARGP_HELP_POST_DOC
)
1627 /* Print any documentation strings at the end. */
1628 anything
|= argp_doc (argp
, state
, 1, anything
, 0, fs
);
1630 if ((flags
& ARGP_HELP_BUG_ADDR
) && argp_program_bug_address
)
1633 __argp_fmtstream_putc (fs
, '\n');
1634 __argp_fmtstream_printf (fs
, dgettext (argp
->argp_domain
,
1635 "Report bugs to %s.\n"),
1636 argp_program_bug_address
);
1640 __funlockfile (stream
);
1645 __argp_fmtstream_free (fs
);
1648 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1649 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1650 void __argp_help (const struct argp
*argp
, FILE *stream
,
1651 unsigned flags
, char *name
)
1653 _help (argp
, 0, stream
, flags
, name
);
1656 weak_alias (__argp_help
, argp_help
)
1659 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1660 from the set ARGP_HELP_*. */
1662 __argp_state_help (const struct argp_state
*state
, FILE *stream
, unsigned flags
)
1664 if ((!state
|| ! (state
->flags
& ARGP_NO_ERRS
)) && stream
)
1666 if (state
&& (state
->flags
& ARGP_LONG_ONLY
))
1667 flags
|= ARGP_HELP_LONG_ONLY
;
1669 _help (state
? state
->root_argp
: 0, state
, stream
, flags
,
1670 state
? state
->name
: program_invocation_short_name
);
1672 if (!state
|| ! (state
->flags
& ARGP_NO_EXIT
))
1674 if (flags
& ARGP_HELP_EXIT_ERR
)
1675 exit (argp_err_exit_status
);
1676 if (flags
& ARGP_HELP_EXIT_OK
)
1682 weak_alias (__argp_state_help
, argp_state_help
)
1685 /* If appropriate, print the printf string FMT and following args, preceded
1686 by the program name and `:', to stderr, and followed by a `Try ... --help'
1687 message, then exit (1). */
1689 __argp_error (const struct argp_state
*state
, const char *fmt
, ...)
1691 if (!state
|| !(state
->flags
& ARGP_NO_ERRS
))
1693 FILE *stream
= state
? state
->err_stream
: stderr
;
1699 __flockfile (stream
);
1701 fputs_unlocked (state
? state
->name
: program_invocation_short_name
,
1703 putc_unlocked (':', stream
);
1704 putc_unlocked (' ', stream
);
1707 vfprintf (stream
, fmt
, ap
);
1710 putc_unlocked ('\n', stream
);
1712 __argp_state_help (state
, stream
, ARGP_HELP_STD_ERR
);
1714 __funlockfile (stream
);
1719 weak_alias (__argp_error
, argp_error
)
1722 /* Similar to the standard gnu error-reporting function error(), but will
1723 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1724 to STATE->err_stream. This is useful for argument parsing code that is
1725 shared between program startup (when exiting is desired) and runtime
1726 option parsing (when typically an error code is returned instead). The
1727 difference between this function and argp_error is that the latter is for
1728 *parsing errors*, and the former is for other problems that occur during
1729 parsing but don't reflect a (syntactic) problem with the input. */
1731 __argp_failure (const struct argp_state
*state
, int status
, int errnum
,
1732 const char *fmt
, ...)
1734 if (!state
|| !(state
->flags
& ARGP_NO_ERRS
))
1736 FILE *stream
= state
? state
->err_stream
: stderr
;
1740 __flockfile (stream
);
1742 fputs_unlocked (state
? state
->name
: program_invocation_short_name
,
1749 putc_unlocked (':', stream
);
1750 putc_unlocked (' ', stream
);
1753 vfprintf (stream
, fmt
, ap
);
1759 putc_unlocked (':', stream
);
1760 putc_unlocked (' ', stream
);
1761 fputs (strerror (errnum
), stream
);
1764 putc_unlocked ('\n', stream
);
1766 __funlockfile (stream
);
1768 if (status
&& (!state
|| !(state
->flags
& ARGP_NO_EXIT
)))
1774 weak_alias (__argp_failure
, argp_failure
)