1 /* Hierarchial argument parsing help output
2 Copyright (C) 1995-2000, 2001, 2002, 2003 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
59 /* This is for other GNU distributions with internationalized messages. */
60 # if defined HAVE_LIBINTL_H || defined _LIBC
64 # define dgettext(domain, msgid) \
65 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
68 # define dgettext(domain, msgid) (msgid)
74 # if !HAVE_DECL_STRERROR_R
75 char *strerror_r (int errnum
, char *buf
, size_t buflen
);
78 # if !HAVE_DECL_STRERROR
79 char *strerror (int errnum
);
85 #include "argp-fmtstream.h"
86 #include "argp-namefrob.h"
88 /* User-selectable (using an environment variable) formatting parameters.
90 These may be specified in an environment variable called `ARGP_HELP_FMT',
91 with a contents like: VAR1=VAL1,VAR2=VAL2,BOOLVAR2,no-BOOLVAR2
92 Where VALn must be a positive integer. The list of variables is in the
93 UPARAM_NAMES vector, below. */
95 /* Default parameters. */
96 #define DUP_ARGS 0 /* True if option argument can be duplicated. */
97 #define DUP_ARGS_NOTE 1 /* True to print a note about duplicate args. */
98 #define SHORT_OPT_COL 2 /* column in which short options start */
99 #define LONG_OPT_COL 6 /* column in which long options start */
100 #define DOC_OPT_COL 2 /* column in which doc options start */
101 #define OPT_DOC_COL 29 /* column in which option text starts */
102 #define HEADER_COL 1 /* column in which group headers are printed */
103 #define USAGE_INDENT 12 /* indentation of wrapped usage lines */
104 #define RMARGIN 79 /* right margin used for wrapping */
106 /* User-selectable (using an environment variable) formatting parameters.
107 They must all be of type `int' for the parsing code to work. */
110 /* If true, arguments for an option are shown with both short and long
111 options, even when a given option has both, e.g. `-x ARG, --longx=ARG'.
112 If false, then if an option has both, the argument is only shown with
113 the long one, e.g., `-x, --longx=ARG', and a message indicating that
114 this really means both is printed below the options. */
117 /* This is true if when DUP_ARGS is false, and some duplicate arguments have
118 been suppressed, an explanatory message should be printed. */
121 /* Various output columns. */
130 int valid
; /* True when the values in here are valid. */
133 /* This is a global variable, as user options are only ever read once. */
134 static struct uparams uparams
= {
135 DUP_ARGS
, DUP_ARGS_NOTE
,
136 SHORT_OPT_COL
, LONG_OPT_COL
, DOC_OPT_COL
, OPT_DOC_COL
, HEADER_COL
,
137 USAGE_INDENT
, RMARGIN
,
141 /* A particular uparam, and what the user name is. */
144 const char *name
; /* User name. */
145 int is_bool
; /* Whether it's `boolean'. */
146 size_t uparams_offs
; /* Location of the (int) field in UPARAMS. */
149 /* The name-field mappings we know about. */
150 static const struct uparam_name uparam_names
[] =
152 { "dup-args", 1, offsetof (struct uparams
, dup_args
) },
153 { "dup-args-note", 1, offsetof (struct uparams
, dup_args_note
) },
154 { "short-opt-col", 0, offsetof (struct uparams
, short_opt_col
) },
155 { "long-opt-col", 0, offsetof (struct uparams
, long_opt_col
) },
156 { "doc-opt-col", 0, offsetof (struct uparams
, doc_opt_col
) },
157 { "opt-doc-col", 0, offsetof (struct uparams
, opt_doc_col
) },
158 { "header-col", 0, offsetof (struct uparams
, header_col
) },
159 { "usage-indent", 0, offsetof (struct uparams
, usage_indent
) },
160 { "rmargin", 0, offsetof (struct uparams
, rmargin
) },
164 /* Read user options from the environment, and fill in UPARAMS appropiately. */
166 fill_in_uparams (const struct argp_state
*state
)
168 const char *var
= getenv ("ARGP_HELP_FMT");
170 #define SKIPWS(p) do { while (isspace (*p)) p++; } while (0);
181 const struct uparam_name
*un
;
182 int unspec
= 0, val
= 0;
183 const char *arg
= var
;
185 while (isalnum (*arg
) || *arg
== '-' || *arg
== '_')
191 if (*arg
== '\0' || *arg
== ',')
193 else if (*arg
== '=')
201 if (var
[0] == 'n' && var
[1] == 'o' && var
[2] == '-')
210 else if (isdigit (*arg
))
213 while (isdigit (*arg
))
218 for (un
= uparam_names
; un
->name
; un
++)
219 if (strlen (un
->name
) == var_len
220 && strncmp (var
, un
->name
, var_len
) == 0)
222 if (unspec
&& !un
->is_bool
)
223 __argp_failure (state
, 0, 0,
224 dgettext (state
->root_argp
->argp_domain
, "\
225 %.*s: ARGP_HELP_FMT parameter requires a value"),
228 *(int *)((char *)&uparams
+ un
->uparams_offs
) = val
;
232 __argp_failure (state
, 0, 0,
233 dgettext (state
->root_argp
->argp_domain
, "\
234 %.*s: Unknown ARGP_HELP_FMT parameter"),
243 __argp_failure (state
, 0, 0,
244 dgettext (state
->root_argp
->argp_domain
,
245 "Garbage in ARGP_HELP_FMT: %s"), var
);
251 /* Returns true if OPT hasn't been marked invisible. Visibility only affects
252 whether OPT is displayed or used in sorting, not option shadowing. */
253 #define ovisible(opt) (! ((opt)->flags & OPTION_HIDDEN))
255 /* Returns true if OPT is an alias for an earlier option. */
256 #define oalias(opt) ((opt)->flags & OPTION_ALIAS)
258 /* Returns true if OPT is an documentation-only entry. */
259 #define odoc(opt) ((opt)->flags & OPTION_DOC)
261 /* Returns true if OPT is the end-of-list marker for a list of options. */
262 #define oend(opt) __option_is_end (opt)
264 /* Returns true if OPT has a short option. */
265 #define oshort(opt) __option_is_short (opt)
268 The help format for a particular option is like:
270 -xARG, -yARG, --long1=ARG, --long2=ARG Documentation...
272 Where ARG will be omitted if there's no argument, for this option, or
273 will be surrounded by "[" and "]" appropiately if the argument is
274 optional. The documentation string is word-wrapped appropiately, and if
275 the list of options is long enough, it will be started on a separate line.
276 If there are no short options for a given option, the first long option is
277 indented slighly in a way that's supposed to make most long options appear
278 to be in a separate column.
280 For example, the following output (from ps):
282 -p PID, --pid=PID List the process PID
283 --pgrp=PGRP List processes in the process group PGRP
284 -P, -x, --no-parent Include processes without parents
285 -Q, --all-fields Don't elide unusable fields (normally if there's
286 some reason ps can't print a field for any
287 process, it's removed from the output entirely)
288 -r, --reverse, --gratuitously-long-reverse-option
289 Reverse the order of any sort
290 --session[=SID] Add the processes from the session SID (which
291 defaults to the sid of the current process)
293 Here are some more options:
294 -f ZOT, --foonly=ZOT Glork a foonly
295 -z, --zaza Snit a zar
297 -?, --help Give this help list
298 --usage Give a short usage message
299 -V, --version Print program version
301 The struct argp_option array for the above could look like:
304 {"pid", 'p', "PID", 0, "List the process PID"},
305 {"pgrp", OPT_PGRP, "PGRP", 0, "List processes in the process group PGRP"},
306 {"no-parent", 'P', 0, 0, "Include processes without parents"},
307 {0, 'x', 0, OPTION_ALIAS},
308 {"all-fields",'Q', 0, 0, "Don't elide unusable fields (normally"
309 " if there's some reason ps can't"
310 " print a field for any process, it's"
311 " removed from the output entirely)" },
312 {"reverse", 'r', 0, 0, "Reverse the order of any sort"},
313 {"gratuitously-long-reverse-option", 0, 0, OPTION_ALIAS},
314 {"session", OPT_SESS, "SID", OPTION_ARG_OPTIONAL,
315 "Add the processes from the session"
316 " SID (which defaults to the sid of"
317 " the current process)" },
319 {0,0,0,0, "Here are some more options:"},
320 {"foonly", 'f', "ZOT", 0, "Glork a foonly"},
321 {"zaza", 'z', 0, 0, "Snit a zar"},
326 Note that the last three options are automatically supplied by argp_parse,
327 unless you tell it not to with ARGP_NO_HELP.
331 /* Returns true if CH occurs between BEG and END. */
333 find_char (char ch
, char *beg
, char *end
)
343 struct hol_cluster
; /* fwd decl */
348 const struct argp_option
*opt
;
349 /* Number of options (including aliases). */
352 /* A pointers into the HOL's short_options field, to the first short option
353 letter for this entry. The order of the characters following this point
354 corresponds to the order of options pointed to by OPT, and there are at
355 most NUM. A short option recorded in a option following OPT is only
356 valid if it occurs in the right place in SHORT_OPTIONS (otherwise it's
357 probably been shadowed by some other entry). */
360 /* Entries are sorted by their group first, in the order:
361 1, 2, ..., n, 0, -m, ..., -2, -1
362 and then alphabetically within each group. The default is 0. */
365 /* The cluster of options this entry belongs to, or 0 if none. */
366 struct hol_cluster
*cluster
;
368 /* The argp from which this option came. */
369 const struct argp
*argp
;
372 /* A cluster of entries to reflect the argp tree structure. */
375 /* A descriptive header printed before options in this cluster. */
378 /* Used to order clusters within the same group with the same parent,
379 according to the order in which they occurred in the parent argp's child
383 /* How to sort this cluster with respect to options and other clusters at the
384 same depth (clusters always follow options in the same group). */
387 /* The cluster to which this cluster belongs, or 0 if it's at the base
389 struct hol_cluster
*parent
;
391 /* The argp from which this cluster is (eventually) derived. */
392 const struct argp
*argp
;
394 /* The distance this cluster is from the root. */
397 /* Clusters in a given hol are kept in a linked list, to make freeing them
399 struct hol_cluster
*next
;
402 /* A list of options for help. */
405 /* An array of hol_entry's. */
406 struct hol_entry
*entries
;
407 /* The number of entries in this hol. If this field is zero, the others
409 unsigned num_entries
;
411 /* A string containing all short options in this HOL. Each entry contains
412 pointers into this string, so the order can't be messed with blindly. */
415 /* Clusters of entries in this hol. */
416 struct hol_cluster
*clusters
;
419 /* Create a struct hol from the options in ARGP. CLUSTER is the
420 hol_cluster in which these entries occur, or 0, if at the root. */
422 make_hol (const struct argp
*argp
, struct hol_cluster
*cluster
)
425 const struct argp_option
*o
;
426 const struct argp_option
*opts
= argp
->options
;
427 struct hol_entry
*entry
;
428 unsigned num_short_options
= 0;
429 struct hol
*hol
= malloc (sizeof (struct hol
));
433 hol
->num_entries
= 0;
440 /* The first option must not be an alias. */
441 assert (! oalias (opts
));
443 /* Calculate the space needed. */
444 for (o
= opts
; ! oend (o
); o
++)
449 num_short_options
++; /* This is an upper bound. */
452 hol
->entries
= malloc (sizeof (struct hol_entry
) * hol
->num_entries
);
453 hol
->short_options
= malloc (num_short_options
+ 1);
455 assert (hol
->entries
&& hol
->short_options
);
457 /* Fill in the entries. */
458 so
= hol
->short_options
;
459 for (o
= opts
, entry
= hol
->entries
; ! oend (o
); entry
++)
463 entry
->short_options
= so
;
464 entry
->group
= cur_group
=
467 : ((!o
->name
&& !o
->key
)
470 entry
->cluster
= cluster
;
476 if (oshort (o
) && ! find_char (o
->key
, hol
->short_options
, so
))
477 /* O has a valid short option which hasn't already been used.*/
481 while (! oend (o
) && oalias (o
));
483 *so
= '\0'; /* null terminated so we can find the length */
489 /* Add a new cluster to HOL, with the given GROUP and HEADER (taken from the
490 associated argp child list entry), INDEX, and PARENT, and return a pointer
491 to it. ARGP is the argp that this cluster results from. */
492 static struct hol_cluster
*
493 hol_add_cluster (struct hol
*hol
, int group
, const char *header
, int index
,
494 struct hol_cluster
*parent
, const struct argp
*argp
)
496 struct hol_cluster
*cl
= malloc (sizeof (struct hol_cluster
));
505 cl
->depth
= parent
? parent
->depth
+ 1 : 0;
507 cl
->next
= hol
->clusters
;
513 /* Free HOL and any resources it uses. */
515 hol_free (struct hol
*hol
)
517 struct hol_cluster
*cl
= hol
->clusters
;
521 struct hol_cluster
*next
= cl
->next
;
526 if (hol
->num_entries
> 0)
529 free (hol
->short_options
);
536 hol_entry_short_iterate (const struct hol_entry
*entry
,
537 int (*func
)(const struct argp_option
*opt
,
538 const struct argp_option
*real
,
539 const char *domain
, void *cookie
),
540 const char *domain
, void *cookie
)
544 const struct argp_option
*opt
, *real
= entry
->opt
;
545 char *so
= entry
->short_options
;
547 for (opt
= real
, nopts
= entry
->num
; nopts
> 0 && !val
; opt
++, nopts
--)
548 if (oshort (opt
) && *so
== opt
->key
)
553 val
= (*func
)(opt
, real
, domain
, cookie
);
561 __attribute__ ((always_inline
))
562 hol_entry_long_iterate (const struct hol_entry
*entry
,
563 int (*func
)(const struct argp_option
*opt
,
564 const struct argp_option
*real
,
565 const char *domain
, void *cookie
),
566 const char *domain
, void *cookie
)
570 const struct argp_option
*opt
, *real
= entry
->opt
;
572 for (opt
= real
, nopts
= entry
->num
; nopts
> 0 && !val
; opt
++, nopts
--)
578 val
= (*func
)(opt
, real
, domain
, cookie
);
584 /* Iterator that returns true for the first short option. */
586 until_short (const struct argp_option
*opt
, const struct argp_option
*real
,
587 const char *domain
, void *cookie
)
589 return oshort (opt
) ? opt
->key
: 0;
592 /* Returns the first valid short option in ENTRY, or 0 if there is none. */
594 hol_entry_first_short (const struct hol_entry
*entry
)
596 return hol_entry_short_iterate (entry
, until_short
,
597 entry
->argp
->argp_domain
, 0);
600 /* Returns the first valid long option in ENTRY, or 0 if there is none. */
602 hol_entry_first_long (const struct hol_entry
*entry
)
604 const struct argp_option
*opt
;
606 for (opt
= entry
->opt
, num
= entry
->num
; num
> 0; opt
++, num
--)
607 if (opt
->name
&& ovisible (opt
))
612 /* Returns the entry in HOL with the long option name NAME, or 0 if there is
614 static struct hol_entry
*
615 hol_find_entry (struct hol
*hol
, const char *name
)
617 struct hol_entry
*entry
= hol
->entries
;
618 unsigned num_entries
= hol
->num_entries
;
620 while (num_entries
-- > 0)
622 const struct argp_option
*opt
= entry
->opt
;
623 unsigned num_opts
= entry
->num
;
625 while (num_opts
-- > 0)
626 if (opt
->name
&& ovisible (opt
) && strcmp (opt
->name
, name
) == 0)
637 /* If an entry with the long option NAME occurs in HOL, set it's special
638 sort position to GROUP. */
640 hol_set_group (struct hol
*hol
, const char *name
, int group
)
642 struct hol_entry
*entry
= hol_find_entry (hol
, name
);
644 entry
->group
= group
;
647 /* Order by group: 0, 1, 2, ..., n, -m, ..., -2, -1.
648 EQ is what to return if GROUP1 and GROUP2 are the same. */
650 group_cmp (int group1
, int group2
, int eq
)
652 if (group1
== group2
)
654 else if ((group1
< 0 && group2
< 0) || (group1
>= 0 && group2
>= 0))
655 return group1
- group2
;
657 return group2
- group1
;
660 /* Compare clusters CL1 & CL2 by the order that they should appear in
663 hol_cluster_cmp (const struct hol_cluster
*cl1
, const struct hol_cluster
*cl2
)
665 /* If one cluster is deeper than the other, use its ancestor at the same
666 level, so that finding the common ancestor is straightforward. */
667 while (cl1
->depth
< cl2
->depth
)
669 while (cl2
->depth
< cl1
->depth
)
672 /* Now reduce both clusters to their ancestors at the point where both have
673 a common parent; these can be directly compared. */
674 while (cl1
->parent
!= cl2
->parent
)
675 cl1
= cl1
->parent
, cl2
= cl2
->parent
;
677 return group_cmp (cl1
->group
, cl2
->group
, cl2
->index
- cl1
->index
);
680 /* Return the ancestor of CL that's just below the root (i.e., has a parent
682 static struct hol_cluster
*
683 hol_cluster_base (struct hol_cluster
*cl
)
690 /* Return true if CL1 is a child of CL2. */
692 hol_cluster_is_child (const struct hol_cluster
*cl1
,
693 const struct hol_cluster
*cl2
)
695 while (cl1
&& cl1
!= cl2
)
700 /* Given the name of a OPTION_DOC option, modifies NAME to start at the tail
701 that should be used for comparisons, and returns true iff it should be
702 treated as a non-option. */
704 canon_doc_option (const char **name
)
707 /* Skip initial whitespace. */
708 while (isspace (**name
))
710 /* Decide whether this looks like an option (leading `-') or not. */
711 non_opt
= (**name
!= '-');
712 /* Skip until part of name used for sorting. */
713 while (**name
&& !isalnum (**name
))
718 /* Order ENTRY1 & ENTRY2 by the order which they should appear in a help
721 hol_entry_cmp (const struct hol_entry
*entry1
,
722 const struct hol_entry
*entry2
)
724 /* The group numbers by which the entries should be ordered; if either is
725 in a cluster, then this is just the group within the cluster. */
726 int group1
= entry1
->group
, group2
= entry2
->group
;
728 if (entry1
->cluster
!= entry2
->cluster
)
730 /* The entries are not within the same cluster, so we can't compare them
731 directly, we have to use the appropiate clustering level too. */
732 if (! entry1
->cluster
)
733 /* ENTRY1 is at the `base level', not in a cluster, so we have to
734 compare it's group number with that of the base cluster in which
735 ENTRY2 resides. Note that if they're in the same group, the
736 clustered option always comes laster. */
737 return group_cmp (group1
, hol_cluster_base (entry2
->cluster
)->group
, -1);
738 else if (! entry2
->cluster
)
739 /* Likewise, but ENTRY2's not in a cluster. */
740 return group_cmp (hol_cluster_base (entry1
->cluster
)->group
, group2
, 1);
742 /* Both entries are in clusters, we can just compare the clusters. */
743 return hol_cluster_cmp (entry1
->cluster
, entry2
->cluster
);
745 else if (group1
== group2
)
746 /* The entries are both in the same cluster and group, so compare them
749 int short1
= hol_entry_first_short (entry1
);
750 int short2
= hol_entry_first_short (entry2
);
751 int doc1
= odoc (entry1
->opt
);
752 int doc2
= odoc (entry2
->opt
);
753 const char *long1
= hol_entry_first_long (entry1
);
754 const char *long2
= hol_entry_first_long (entry2
);
757 doc1
= canon_doc_option (&long1
);
759 doc2
= canon_doc_option (&long2
);
762 /* `documentation' options always follow normal options (or
763 documentation options that *look* like normal options). */
765 else if (!short1
&& !short2
&& long1
&& long2
)
766 /* Only long options. */
767 return __strcasecmp (long1
, long2
);
769 /* Compare short/short, long/short, short/long, using the first
770 character of long options. Entries without *any* valid
771 options (such as options with OPTION_HIDDEN set) will be put
772 first, but as they're not displayed, it doesn't matter where
775 char first1
= short1
? short1
: long1
? *long1
: 0;
776 char first2
= short2
? short2
: long2
? *long2
: 0;
778 int lower_cmp
= _tolower (first1
) - _tolower (first2
);
780 int lower_cmp
= tolower (first1
) - tolower (first2
);
782 /* Compare ignoring case, except when the options are both the
783 same letter, in which case lower-case always comes first. */
784 return lower_cmp
? lower_cmp
: first2
- first1
;
788 /* Within the same cluster, but not the same group, so just compare
790 return group_cmp (group1
, group2
, 0);
793 /* Version of hol_entry_cmp with correct signature for qsort. */
795 hol_entry_qcmp (const void *entry1_v
, const void *entry2_v
)
797 return hol_entry_cmp (entry1_v
, entry2_v
);
800 /* Sort HOL by group and alphabetically by option name (with short options
801 taking precedence over long). Since the sorting is for display purposes
802 only, the shadowing of options isn't effected. */
804 hol_sort (struct hol
*hol
)
806 if (hol
->num_entries
> 0)
807 qsort (hol
->entries
, hol
->num_entries
, sizeof (struct hol_entry
),
811 /* Append MORE to HOL, destroying MORE in the process. Options in HOL shadow
812 any in MORE with the same name. */
814 hol_append (struct hol
*hol
, struct hol
*more
)
816 struct hol_cluster
**cl_end
= &hol
->clusters
;
818 /* Steal MORE's cluster list, and add it to the end of HOL's. */
820 cl_end
= &(*cl_end
)->next
;
821 *cl_end
= more
->clusters
;
825 if (more
->num_entries
> 0)
827 if (hol
->num_entries
== 0)
829 hol
->num_entries
= more
->num_entries
;
830 hol
->entries
= more
->entries
;
831 hol
->short_options
= more
->short_options
;
832 more
->num_entries
= 0; /* Mark MORE's fields as invalid. */
835 /* Append the entries in MORE to those in HOL, taking care to only add
836 non-shadowed SHORT_OPTIONS values. */
841 unsigned num_entries
= hol
->num_entries
+ more
->num_entries
;
842 struct hol_entry
*entries
=
843 malloc (num_entries
* sizeof (struct hol_entry
));
844 unsigned hol_so_len
= strlen (hol
->short_options
);
845 char *short_options
=
846 malloc (hol_so_len
+ strlen (more
->short_options
) + 1);
848 __mempcpy (__mempcpy (entries
, hol
->entries
,
849 hol
->num_entries
* sizeof (struct hol_entry
)),
851 more
->num_entries
* sizeof (struct hol_entry
));
853 __mempcpy (short_options
, hol
->short_options
, hol_so_len
);
855 /* Fix up the short options pointers from HOL. */
856 for (e
= entries
, left
= hol
->num_entries
; left
> 0; e
++, left
--)
857 e
->short_options
+= (short_options
- hol
->short_options
);
859 /* Now add the short options from MORE, fixing up its entries
861 so
= short_options
+ hol_so_len
;
862 more_so
= more
->short_options
;
863 for (left
= more
->num_entries
; left
> 0; e
++, left
--)
866 const struct argp_option
*opt
;
868 e
->short_options
= so
;
870 for (opts_left
= e
->num
, opt
= e
->opt
; opts_left
; opt
++, opts_left
--)
873 if (oshort (opt
) && ch
== opt
->key
)
874 /* The next short option in MORE_SO, CH, is from OPT. */
876 if (! find_char (ch
, short_options
,
877 short_options
+ hol_so_len
))
878 /* The short option CH isn't shadowed by HOL's options,
879 so add it to the sum. */
889 free (hol
->short_options
);
891 hol
->entries
= entries
;
892 hol
->num_entries
= num_entries
;
893 hol
->short_options
= short_options
;
900 /* Inserts enough spaces to make sure STREAM is at column COL. */
902 indent_to (argp_fmtstream_t stream
, unsigned col
)
904 int needed
= col
- __argp_fmtstream_point (stream
);
906 __argp_fmtstream_putc (stream
, ' ');
909 /* Output to STREAM either a space, or a newline if there isn't room for at
910 least ENSURE characters before the right margin. */
912 space (argp_fmtstream_t stream
, size_t ensure
)
914 if (__argp_fmtstream_point (stream
) + ensure
915 >= __argp_fmtstream_rmargin (stream
))
916 __argp_fmtstream_putc (stream
, '\n');
918 __argp_fmtstream_putc (stream
, ' ');
921 /* If the option REAL has an argument, we print it in using the printf
922 format REQ_FMT or OPT_FMT depending on whether it's a required or
923 optional argument. */
925 arg (const struct argp_option
*real
, const char *req_fmt
, const char *opt_fmt
,
926 const char *domain
, argp_fmtstream_t stream
)
930 if (real
->flags
& OPTION_ARG_OPTIONAL
)
931 __argp_fmtstream_printf (stream
, opt_fmt
,
932 dgettext (domain
, real
->arg
));
934 __argp_fmtstream_printf (stream
, req_fmt
,
935 dgettext (domain
, real
->arg
));
939 /* Helper functions for hol_entry_help. */
941 /* State used during the execution of hol_help. */
942 struct hol_help_state
944 /* PREV_ENTRY should contain the previous entry printed, or 0. */
945 struct hol_entry
*prev_entry
;
947 /* If an entry is in a different group from the previous one, and SEP_GROUPS
948 is true, then a blank line will be printed before any output. */
951 /* True if a duplicate option argument was suppressed (only ever set if
952 UPARAMS.dup_args is false). */
953 int suppressed_dup_arg
;
956 /* Some state used while printing a help entry (used to communicate with
957 helper functions). See the doc for hol_entry_help for more info, as most
958 of the fields are copied from its arguments. */
961 const struct hol_entry
*entry
;
962 argp_fmtstream_t stream
;
963 struct hol_help_state
*hhstate
;
965 /* True if nothing's been printed so far. */
968 /* If non-zero, the state that was used to print this help. */
969 const struct argp_state
*state
;
972 /* If a user doc filter should be applied to DOC, do so. */
974 filter_doc (const char *doc
, int key
, const struct argp
*argp
,
975 const struct argp_state
*state
)
977 if (argp
->help_filter
)
978 /* We must apply a user filter to this output. */
980 void *input
= __argp_input (argp
, state
);
981 return (*argp
->help_filter
) (key
, doc
, input
);
988 /* Prints STR as a header line, with the margin lines set appropiately, and
989 notes the fact that groups should be separated with a blank line. ARGP is
990 the argp that should dictate any user doc filtering to take place. Note
991 that the previous wrap margin isn't restored, but the left margin is reset
994 print_header (const char *str
, const struct argp
*argp
,
995 struct pentry_state
*pest
)
997 const char *tstr
= dgettext (argp
->argp_domain
, str
);
998 const char *fstr
= filter_doc (tstr
, ARGP_KEY_HELP_HEADER
, argp
, pest
->state
);
1004 if (pest
->hhstate
->prev_entry
)
1005 /* Precede with a blank line. */
1006 __argp_fmtstream_putc (pest
->stream
, '\n');
1007 indent_to (pest
->stream
, uparams
.header_col
);
1008 __argp_fmtstream_set_lmargin (pest
->stream
, uparams
.header_col
);
1009 __argp_fmtstream_set_wmargin (pest
->stream
, uparams
.header_col
);
1010 __argp_fmtstream_puts (pest
->stream
, fstr
);
1011 __argp_fmtstream_set_lmargin (pest
->stream
, 0);
1012 __argp_fmtstream_putc (pest
->stream
, '\n');
1015 pest
->hhstate
->sep_groups
= 1; /* Separate subsequent groups. */
1019 free ((char *) fstr
);
1022 /* Inserts a comma if this isn't the first item on the line, and then makes
1023 sure we're at least to column COL. If this *is* the first item on a line,
1024 prints any pending whitespace/headers that should precede this line. Also
1027 comma (unsigned col
, struct pentry_state
*pest
)
1031 const struct hol_entry
*pe
= pest
->hhstate
->prev_entry
;
1032 const struct hol_cluster
*cl
= pest
->entry
->cluster
;
1034 if (pest
->hhstate
->sep_groups
&& pe
&& pest
->entry
->group
!= pe
->group
)
1035 __argp_fmtstream_putc (pest
->stream
, '\n');
1037 if (cl
&& cl
->header
&& *cl
->header
1039 || (pe
->cluster
!= cl
1040 && !hol_cluster_is_child (pe
->cluster
, cl
))))
1041 /* If we're changing clusters, then this must be the start of the
1042 ENTRY's cluster unless that is an ancestor of the previous one
1043 (in which case we had just popped into a sub-cluster for a bit).
1044 If so, then print the cluster's header line. */
1046 int old_wm
= __argp_fmtstream_wmargin (pest
->stream
);
1047 print_header (cl
->header
, cl
->argp
, pest
);
1048 __argp_fmtstream_set_wmargin (pest
->stream
, old_wm
);
1054 __argp_fmtstream_puts (pest
->stream
, ", ");
1056 indent_to (pest
->stream
, col
);
1059 /* Print help for ENTRY to STREAM. */
1061 hol_entry_help (struct hol_entry
*entry
, const struct argp_state
*state
,
1062 argp_fmtstream_t stream
, struct hol_help_state
*hhstate
)
1065 const struct argp_option
*real
= entry
->opt
, *opt
;
1066 char *so
= entry
->short_options
;
1067 int have_long_opt
= 0; /* We have any long options. */
1068 /* Saved margins. */
1069 int old_lm
= __argp_fmtstream_set_lmargin (stream
, 0);
1070 int old_wm
= __argp_fmtstream_wmargin (stream
);
1071 /* PEST is a state block holding some of our variables that we'd like to
1072 share with helper functions. */
1073 struct pentry_state pest
= { entry
, stream
, hhstate
, 1, state
};
1076 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1077 if (opt
->name
&& ovisible (opt
))
1083 /* First emit short options. */
1084 __argp_fmtstream_set_wmargin (stream
, uparams
.short_opt_col
); /* For truly bizarre cases. */
1085 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1086 if (oshort (opt
) && opt
->key
== *so
)
1087 /* OPT has a valid (non shadowed) short option. */
1091 comma (uparams
.short_opt_col
, &pest
);
1092 __argp_fmtstream_putc (stream
, '-');
1093 __argp_fmtstream_putc (stream
, *so
);
1094 if (!have_long_opt
|| uparams
.dup_args
)
1095 arg (real
, " %s", "[%s]", state
->root_argp
->argp_domain
, stream
);
1097 hhstate
->suppressed_dup_arg
= 1;
1102 /* Now, long options. */
1104 /* A `documentation' option. */
1106 __argp_fmtstream_set_wmargin (stream
, uparams
.doc_opt_col
);
1107 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1108 if (opt
->name
&& ovisible (opt
))
1110 comma (uparams
.doc_opt_col
, &pest
);
1111 /* Calling gettext here isn't quite right, since sorting will
1112 have been done on the original; but documentation options
1113 should be pretty rare anyway... */
1114 __argp_fmtstream_puts (stream
,
1115 dgettext (state
->root_argp
->argp_domain
,
1120 /* A real long option. */
1122 int first_long_opt
= 1;
1124 __argp_fmtstream_set_wmargin (stream
, uparams
.long_opt_col
);
1125 for (opt
= real
, num
= entry
->num
; num
> 0; opt
++, num
--)
1126 if (opt
->name
&& ovisible (opt
))
1128 comma (uparams
.long_opt_col
, &pest
);
1129 __argp_fmtstream_printf (stream
, "--%s", opt
->name
);
1130 if (first_long_opt
|| uparams
.dup_args
)
1131 arg (real
, "=%s", "[=%s]", state
->root_argp
->argp_domain
,
1134 hhstate
->suppressed_dup_arg
= 1;
1138 /* Next, documentation strings. */
1139 __argp_fmtstream_set_lmargin (stream
, 0);
1143 /* Didn't print any switches, what's up? */
1144 if (!oshort (real
) && !real
->name
)
1145 /* This is a group header, print it nicely. */
1146 print_header (real
->doc
, entry
->argp
, &pest
);
1148 /* Just a totally shadowed option or null header; print nothing. */
1149 goto cleanup
; /* Just return, after cleaning up. */
1153 const char *tstr
= real
->doc
? dgettext (state
->root_argp
->argp_domain
,
1155 const char *fstr
= filter_doc (tstr
, real
->key
, entry
->argp
, state
);
1158 unsigned int col
= __argp_fmtstream_point (stream
);
1160 __argp_fmtstream_set_lmargin (stream
, uparams
.opt_doc_col
);
1161 __argp_fmtstream_set_wmargin (stream
, uparams
.opt_doc_col
);
1163 if (col
> (unsigned int) (uparams
.opt_doc_col
+ 3))
1164 __argp_fmtstream_putc (stream
, '\n');
1165 else if (col
>= (unsigned int) uparams
.opt_doc_col
)
1166 __argp_fmtstream_puts (stream
, " ");
1168 indent_to (stream
, uparams
.opt_doc_col
);
1170 __argp_fmtstream_puts (stream
, fstr
);
1172 if (fstr
&& fstr
!= tstr
)
1173 free ((char *) fstr
);
1175 /* Reset the left margin. */
1176 __argp_fmtstream_set_lmargin (stream
, 0);
1177 __argp_fmtstream_putc (stream
, '\n');
1180 hhstate
->prev_entry
= entry
;
1183 __argp_fmtstream_set_lmargin (stream
, old_lm
);
1184 __argp_fmtstream_set_wmargin (stream
, old_wm
);
1187 /* Output a long help message about the options in HOL to STREAM. */
1189 hol_help (struct hol
*hol
, const struct argp_state
*state
,
1190 argp_fmtstream_t stream
)
1193 struct hol_entry
*entry
;
1194 struct hol_help_state hhstate
= { 0, 0, 0 };
1196 for (entry
= hol
->entries
, num
= hol
->num_entries
; num
> 0; entry
++, num
--)
1197 hol_entry_help (entry
, state
, stream
, &hhstate
);
1199 if (hhstate
.suppressed_dup_arg
&& uparams
.dup_args_note
)
1201 const char *tstr
= dgettext (state
->root_argp
->argp_domain
, "\
1202 Mandatory or optional arguments to long options are also mandatory or \
1203 optional for any corresponding short options.");
1204 const char *fstr
= filter_doc (tstr
, ARGP_KEY_HELP_DUP_ARGS_NOTE
,
1205 state
? state
->root_argp
: 0, state
);
1208 __argp_fmtstream_putc (stream
, '\n');
1209 __argp_fmtstream_puts (stream
, fstr
);
1210 __argp_fmtstream_putc (stream
, '\n');
1212 if (fstr
&& fstr
!= tstr
)
1213 free ((char *) fstr
);
1217 /* Helper functions for hol_usage. */
1219 /* If OPT is a short option without an arg, append its key to the string
1220 pointer pointer to by COOKIE, and advance the pointer. */
1222 add_argless_short_opt (const struct argp_option
*opt
,
1223 const struct argp_option
*real
,
1224 const char *domain
, void *cookie
)
1226 char **snao_end
= cookie
;
1227 if (!(opt
->arg
|| real
->arg
)
1228 && !((opt
->flags
| real
->flags
) & OPTION_NO_USAGE
))
1229 *(*snao_end
)++ = opt
->key
;
1233 /* If OPT is a short option with an arg, output a usage entry for it to the
1234 stream pointed at by COOKIE. */
1236 usage_argful_short_opt (const struct argp_option
*opt
,
1237 const struct argp_option
*real
,
1238 const char *domain
, void *cookie
)
1240 argp_fmtstream_t stream
= cookie
;
1241 const char *arg
= opt
->arg
;
1242 int flags
= opt
->flags
| real
->flags
;
1247 if (arg
&& !(flags
& OPTION_NO_USAGE
))
1249 arg
= dgettext (domain
, arg
);
1251 if (flags
& OPTION_ARG_OPTIONAL
)
1252 __argp_fmtstream_printf (stream
, " [-%c[%s]]", opt
->key
, arg
);
1255 /* Manually do line wrapping so that it (probably) won't
1256 get wrapped at the embedded space. */
1257 space (stream
, 6 + strlen (arg
));
1258 __argp_fmtstream_printf (stream
, "[-%c %s]", opt
->key
, arg
);
1265 /* Output a usage entry for the long option opt to the stream pointed at by
1268 usage_long_opt (const struct argp_option
*opt
,
1269 const struct argp_option
*real
,
1270 const char *domain
, void *cookie
)
1272 argp_fmtstream_t stream
= cookie
;
1273 const char *arg
= opt
->arg
;
1274 int flags
= opt
->flags
| real
->flags
;
1279 if (! (flags
& OPTION_NO_USAGE
))
1283 arg
= dgettext (domain
, arg
);
1284 if (flags
& OPTION_ARG_OPTIONAL
)
1285 __argp_fmtstream_printf (stream
, " [--%s[=%s]]", opt
->name
, arg
);
1287 __argp_fmtstream_printf (stream
, " [--%s=%s]", opt
->name
, arg
);
1290 __argp_fmtstream_printf (stream
, " [--%s]", opt
->name
);
1296 /* Print a short usage description for the arguments in HOL to STREAM. */
1298 hol_usage (struct hol
*hol
, argp_fmtstream_t stream
)
1300 if (hol
->num_entries
> 0)
1303 struct hol_entry
*entry
;
1304 char *short_no_arg_opts
= alloca (strlen (hol
->short_options
) + 1);
1305 char *snao_end
= short_no_arg_opts
;
1307 /* First we put a list of short options without arguments. */
1308 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1310 ; entry
++, nentries
--)
1311 hol_entry_short_iterate (entry
, add_argless_short_opt
,
1312 entry
->argp
->argp_domain
, &snao_end
);
1313 if (snao_end
> short_no_arg_opts
)
1316 __argp_fmtstream_printf (stream
, " [-%s]", short_no_arg_opts
);
1319 /* Now a list of short options *with* arguments. */
1320 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1322 ; entry
++, nentries
--)
1323 hol_entry_short_iterate (entry
, usage_argful_short_opt
,
1324 entry
->argp
->argp_domain
, stream
);
1326 /* Finally, a list of long options (whew!). */
1327 for (entry
= hol
->entries
, nentries
= hol
->num_entries
1329 ; entry
++, nentries
--)
1330 hol_entry_long_iterate (entry
, usage_long_opt
,
1331 entry
->argp
->argp_domain
, stream
);
1335 /* Make a HOL containing all levels of options in ARGP. CLUSTER is the
1336 cluster in which ARGP's entries should be clustered, or 0. */
1338 argp_hol (const struct argp
*argp
, struct hol_cluster
*cluster
)
1340 const struct argp_child
*child
= argp
->children
;
1341 struct hol
*hol
= make_hol (argp
, cluster
);
1345 struct hol_cluster
*child_cluster
=
1346 ((child
->group
|| child
->header
)
1347 /* Put CHILD->argp within its own cluster. */
1348 ? hol_add_cluster (hol
, child
->group
, child
->header
,
1349 child
- argp
->children
, cluster
, argp
)
1350 /* Just merge it into the parent's cluster. */
1352 hol_append (hol
, argp_hol (child
->argp
, child_cluster
)) ;
1358 /* Calculate how many different levels with alternative args strings exist in
1361 argp_args_levels (const struct argp
*argp
)
1364 const struct argp_child
*child
= argp
->children
;
1366 if (argp
->args_doc
&& strchr (argp
->args_doc
, '\n'))
1371 levels
+= argp_args_levels ((child
++)->argp
);
1376 /* Print all the non-option args documented in ARGP to STREAM. Any output is
1377 preceded by a space. LEVELS is a pointer to a byte vector the length
1378 returned by argp_args_levels; it should be initialized to zero, and
1379 updated by this routine for the next call if ADVANCE is true. True is
1380 returned as long as there are more patterns to output. */
1382 argp_args_usage (const struct argp
*argp
, const struct argp_state
*state
,
1383 char **levels
, int advance
, argp_fmtstream_t stream
)
1385 char *our_level
= *levels
;
1387 const struct argp_child
*child
= argp
->children
;
1388 const char *tdoc
= dgettext (argp
->argp_domain
, argp
->args_doc
), *nl
= 0;
1389 const char *fdoc
= filter_doc (tdoc
, ARGP_KEY_HELP_ARGS_DOC
, argp
, state
);
1393 const char *cp
= fdoc
;
1394 nl
= __strchrnul (cp
, '\n');
1396 /* This is a `multi-level' args doc; advance to the correct position
1397 as determined by our state in LEVELS, and update LEVELS. */
1401 for (i
= 0; i
< *our_level
; i
++)
1402 cp
= nl
+ 1, nl
= __strchrnul (cp
, '\n');
1406 /* Manually do line wrapping so that it (probably) won't get wrapped at
1407 any embedded spaces. */
1408 space (stream
, 1 + nl
- cp
);
1410 __argp_fmtstream_write (stream
, cp
, nl
- cp
);
1412 if (fdoc
&& fdoc
!= tdoc
)
1413 free ((char *)fdoc
); /* Free user's modified doc string. */
1417 advance
= !argp_args_usage ((child
++)->argp
, state
, levels
, advance
, stream
);
1419 if (advance
&& multiple
)
1421 /* Need to increment our level. */
1423 /* There's more we can do here. */
1426 advance
= 0; /* Our parent shouldn't advance also. */
1428 else if (*our_level
> 0)
1429 /* We had multiple levels, but used them up; reset to zero. */
1436 /* Print the documentation for ARGP to STREAM; if POST is false, then
1437 everything preceeding a `\v' character in the documentation strings (or
1438 the whole string, for those with none) is printed, otherwise, everything
1439 following the `\v' character (nothing for strings without). Each separate
1440 bit of documentation is separated a blank line, and if PRE_BLANK is true,
1441 then the first is as well. If FIRST_ONLY is true, only the first
1442 occurrence is output. Returns true if anything was output. */
1444 argp_doc (const struct argp
*argp
, const struct argp_state
*state
,
1445 int post
, int pre_blank
, int first_only
,
1446 argp_fmtstream_t stream
)
1449 const char *inp_text
;
1452 size_t inp_text_limit
= 0;
1453 const char *doc
= dgettext (argp
->argp_domain
, argp
->doc
);
1454 const struct argp_child
*child
= argp
->children
;
1458 char *vt
= strchr (doc
, '\v');
1459 inp_text
= post
? (vt
? vt
+ 1 : 0) : doc
;
1460 inp_text_limit
= (!post
&& vt
) ? (vt
- doc
) : 0;
1465 if (argp
->help_filter
)
1466 /* We have to filter the doc strings. */
1469 /* Copy INP_TEXT so that it's nul-terminated. */
1470 inp_text
= __strndup (inp_text
, inp_text_limit
);
1471 input
= __argp_input (argp
, state
);
1473 (*argp
->help_filter
) (post
1474 ? ARGP_KEY_HELP_POST_DOC
1475 : ARGP_KEY_HELP_PRE_DOC
,
1479 text
= (const char *) inp_text
;
1484 __argp_fmtstream_putc (stream
, '\n');
1486 if (text
== inp_text
&& inp_text_limit
)
1487 __argp_fmtstream_write (stream
, inp_text
, inp_text_limit
);
1489 __argp_fmtstream_puts (stream
, text
);
1491 if (__argp_fmtstream_point (stream
) > __argp_fmtstream_lmargin (stream
))
1492 __argp_fmtstream_putc (stream
, '\n');
1497 if (text
&& text
!= inp_text
)
1498 free ((char *) text
); /* Free TEXT returned from the help filter. */
1499 if (inp_text
&& inp_text_limit
&& argp
->help_filter
)
1500 free ((char *) inp_text
); /* We copied INP_TEXT, so free it now. */
1502 if (post
&& argp
->help_filter
)
1503 /* Now see if we have to output a ARGP_KEY_HELP_EXTRA text. */
1505 text
= (*argp
->help_filter
) (ARGP_KEY_HELP_EXTRA
, 0, input
);
1508 if (anything
|| pre_blank
)
1509 __argp_fmtstream_putc (stream
, '\n');
1510 __argp_fmtstream_puts (stream
, text
);
1511 free ((char *) text
);
1512 if (__argp_fmtstream_point (stream
)
1513 > __argp_fmtstream_lmargin (stream
))
1514 __argp_fmtstream_putc (stream
, '\n');
1520 while (child
->argp
&& !(first_only
&& anything
))
1522 argp_doc ((child
++)->argp
, state
,
1523 post
, anything
|| pre_blank
, first_only
,
1529 /* Output a usage message for ARGP to STREAM. If called from
1530 argp_state_help, STATE is the relevent parsing state. FLAGS are from the
1531 set ARGP_HELP_*. NAME is what to use wherever a `program name' is
1534 _help (const struct argp
*argp
, const struct argp_state
*state
, FILE *stream
,
1535 unsigned flags
, char *name
)
1537 int anything
= 0; /* Whether we've output anything. */
1538 struct hol
*hol
= 0;
1539 argp_fmtstream_t fs
;
1544 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1545 __flockfile (stream
);
1548 if (! uparams
.valid
)
1549 fill_in_uparams (state
);
1551 fs
= __argp_make_fmtstream (stream
, 0, uparams
.rmargin
, 0);
1554 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1555 __funlockfile (stream
);
1560 if (flags
& (ARGP_HELP_USAGE
| ARGP_HELP_SHORT_USAGE
| ARGP_HELP_LONG
))
1562 hol
= argp_hol (argp
, 0);
1564 /* If present, these options always come last. */
1565 hol_set_group (hol
, "help", -1);
1566 hol_set_group (hol
, "version", -1);
1571 if (flags
& (ARGP_HELP_USAGE
| ARGP_HELP_SHORT_USAGE
))
1572 /* Print a short `Usage:' message. */
1574 int first_pattern
= 1, more_patterns
;
1575 size_t num_pattern_levels
= argp_args_levels (argp
);
1576 char *pattern_levels
= alloca (num_pattern_levels
);
1578 memset (pattern_levels
, 0, num_pattern_levels
);
1583 int old_wm
= __argp_fmtstream_set_wmargin (fs
, uparams
.usage_indent
);
1584 char *levels
= pattern_levels
;
1587 __argp_fmtstream_printf (fs
, "%s %s",
1588 dgettext (argp
->argp_domain
, "Usage:"),
1591 __argp_fmtstream_printf (fs
, "%s %s",
1592 dgettext (argp
->argp_domain
, " or: "),
1595 /* We set the lmargin as well as the wmargin, because hol_usage
1596 manually wraps options with newline to avoid annoying breaks. */
1597 old_lm
= __argp_fmtstream_set_lmargin (fs
, uparams
.usage_indent
);
1599 if (flags
& ARGP_HELP_SHORT_USAGE
)
1600 /* Just show where the options go. */
1602 if (hol
->num_entries
> 0)
1603 __argp_fmtstream_puts (fs
, dgettext (argp
->argp_domain
,
1607 /* Actually print the options. */
1609 hol_usage (hol
, fs
);
1610 flags
|= ARGP_HELP_SHORT_USAGE
; /* But only do so once. */
1613 more_patterns
= argp_args_usage (argp
, state
, &levels
, 1, fs
);
1615 __argp_fmtstream_set_wmargin (fs
, old_wm
);
1616 __argp_fmtstream_set_lmargin (fs
, old_lm
);
1618 __argp_fmtstream_putc (fs
, '\n');
1623 while (more_patterns
);
1626 if (flags
& ARGP_HELP_PRE_DOC
)
1627 anything
|= argp_doc (argp
, state
, 0, 0, 1, fs
);
1629 if (flags
& ARGP_HELP_SEE
)
1631 __argp_fmtstream_printf (fs
, dgettext (argp
->argp_domain
, "\
1632 Try `%s --help' or `%s --usage' for more information.\n"),
1637 if (flags
& ARGP_HELP_LONG
)
1638 /* Print a long, detailed help message. */
1640 /* Print info about all the options. */
1641 if (hol
->num_entries
> 0)
1644 __argp_fmtstream_putc (fs
, '\n');
1645 hol_help (hol
, state
, fs
);
1650 if (flags
& ARGP_HELP_POST_DOC
)
1651 /* Print any documentation strings at the end. */
1652 anything
|= argp_doc (argp
, state
, 1, anything
, 0, fs
);
1654 if ((flags
& ARGP_HELP_BUG_ADDR
) && argp_program_bug_address
)
1657 __argp_fmtstream_putc (fs
, '\n');
1658 __argp_fmtstream_printf (fs
, dgettext (argp
->argp_domain
,
1659 "Report bugs to %s.\n"),
1660 argp_program_bug_address
);
1664 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1665 __funlockfile (stream
);
1671 __argp_fmtstream_free (fs
);
1674 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
1675 ARGP_HELP_*. NAME is what to use wherever a `program name' is needed. */
1676 void __argp_help (const struct argp
*argp
, FILE *stream
,
1677 unsigned flags
, char *name
)
1679 _help (argp
, 0, stream
, flags
, name
);
1682 weak_alias (__argp_help
, argp_help
)
1686 char *__argp_basename (char *name
)
1688 char *short_name
= strrchr (name
, '/');
1689 return short_name
? short_name
+ 1 : name
;
1694 __argp_short_program_name (void)
1696 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
1697 return program_invocation_short_name
;
1698 #elif HAVE_DECL_PROGRAM_INVOCATION_NAME
1699 return __argp_basename (program_invocation_name
);
1701 /* FIXME: What now? Miles suggests that it is better to use NULL,
1702 but currently the value is passed on directly to fputs_unlocked,
1703 so that requires more changes. */
1705 # warning No reasonable value to return
1706 #endif /* __GNUC__ */
1711 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
1712 from the set ARGP_HELP_*. */
1714 __argp_state_help (const struct argp_state
*state
, FILE *stream
, unsigned flags
)
1716 if ((!state
|| ! (state
->flags
& ARGP_NO_ERRS
)) && stream
)
1718 if (state
&& (state
->flags
& ARGP_LONG_ONLY
))
1719 flags
|= ARGP_HELP_LONG_ONLY
;
1721 _help (state
? state
->root_argp
: 0, state
, stream
, flags
,
1722 state
? state
->name
: __argp_short_program_name ());
1724 if (!state
|| ! (state
->flags
& ARGP_NO_EXIT
))
1726 if (flags
& ARGP_HELP_EXIT_ERR
)
1727 exit (argp_err_exit_status
);
1728 if (flags
& ARGP_HELP_EXIT_OK
)
1734 weak_alias (__argp_state_help
, argp_state_help
)
1737 /* If appropriate, print the printf string FMT and following args, preceded
1738 by the program name and `:', to stderr, and followed by a `Try ... --help'
1739 message, then exit (1). */
1741 __argp_error (const struct argp_state
*state
, const char *fmt
, ...)
1743 if (!state
|| !(state
->flags
& ARGP_NO_ERRS
))
1745 FILE *stream
= state
? state
->err_stream
: stderr
;
1751 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1752 __flockfile (stream
);
1758 if (_IO_fwide (stream
, 0) > 0)
1762 __asprintf (&buf
, fmt
, ap
);
1764 __fwprintf (stream
, L
"%s: %s\n",
1765 state
? state
->name
: __argp_short_program_name (),
1773 fputs_unlocked (state
1774 ? state
->name
: __argp_short_program_name (),
1776 putc_unlocked (':', stream
);
1777 putc_unlocked (' ', stream
);
1779 vfprintf (stream
, fmt
, ap
);
1781 putc_unlocked ('\n', stream
);
1784 __argp_state_help (state
, stream
, ARGP_HELP_STD_ERR
);
1788 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1789 __funlockfile (stream
);
1795 weak_alias (__argp_error
, argp_error
)
1798 /* Similar to the standard gnu error-reporting function error(), but will
1799 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
1800 to STATE->err_stream. This is useful for argument parsing code that is
1801 shared between program startup (when exiting is desired) and runtime
1802 option parsing (when typically an error code is returned instead). The
1803 difference between this function and argp_error is that the latter is for
1804 *parsing errors*, and the former is for other problems that occur during
1805 parsing but don't reflect a (syntactic) problem with the input. */
1807 __argp_failure (const struct argp_state
*state
, int status
, int errnum
,
1808 const char *fmt
, ...)
1810 if (!state
|| !(state
->flags
& ARGP_NO_ERRS
))
1812 FILE *stream
= state
? state
->err_stream
: stderr
;
1816 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1817 __flockfile (stream
);
1821 if (_IO_fwide (stream
, 0) > 0)
1822 __fwprintf (stream
, L
"%s",
1823 state
? state
->name
: __argp_short_program_name ());
1826 fputs_unlocked (state
1827 ? state
->name
: __argp_short_program_name (),
1836 if (_IO_fwide (stream
, 0) > 0)
1840 __asprintf (&buf
, fmt
, ap
);
1842 __fwprintf (stream
, L
": %s", buf
);
1849 putc_unlocked (':', stream
);
1850 putc_unlocked (' ', stream
);
1852 vfprintf (stream
, fmt
, ap
);
1863 if (_IO_fwide (stream
, 0) > 0)
1864 __fwprintf (stream
, L
": %s",
1865 __strerror_r (errnum
, buf
, sizeof (buf
)));
1869 putc_unlocked (':', stream
);
1870 putc_unlocked (' ', stream
);
1871 #if defined _LIBC || defined HAVE_STRERROR_R
1872 fputs (__strerror_r (errnum
, buf
, sizeof (buf
)), stream
);
1874 fputs (strerror (errnum
), stream
);
1880 if (_IO_fwide (stream
, 0) > 0)
1881 putwc_unlocked (L
'\n', stream
);
1884 putc_unlocked ('\n', stream
);
1886 #if _LIBC || (HAVE_FLOCKFILE && HAVE_FUNLOCKFILE)
1887 __funlockfile (stream
);
1890 if (status
&& (!state
|| !(state
->flags
& ARGP_NO_EXIT
)))
1896 weak_alias (__argp_failure
, argp_failure
)