diff options
Diffstat (limited to 'meta/recipes-core/uclibc/uclibc-git/argp-headers.patch')
-rw-r--r-- | meta/recipes-core/uclibc/uclibc-git/argp-headers.patch | 581 |
1 files changed, 581 insertions, 0 deletions
diff --git a/meta/recipes-core/uclibc/uclibc-git/argp-headers.patch b/meta/recipes-core/uclibc/uclibc-git/argp-headers.patch new file mode 100644 index 0000000000..7fd148fed2 --- /dev/null +++ b/meta/recipes-core/uclibc/uclibc-git/argp-headers.patch | |||
@@ -0,0 +1,581 @@ | |||
1 | Added headers file needed by argp sources. | ||
2 | |||
3 | Signed-off-by: Salvatore Cro <salvatore.cro at st.com> | ||
4 | --- | ||
5 | include/argp.h | 566 ++++++++++++++++++++++++++++++++++++++++++++ | ||
6 | libc/argp/argp-fmtstream.h | 314 ++++++++++++++++++++++++ | ||
7 | 2 files changed, 880 insertions(+), 0 deletions(-) | ||
8 | create mode 100644 include/argp.h | ||
9 | create mode 100644 libc/argp/argp-fmtstream.h | ||
10 | |||
11 | Index: git/include/argp.h | ||
12 | =================================================================== | ||
13 | --- /dev/null | ||
14 | +++ git/include/argp.h | ||
15 | @@ -0,0 +1,566 @@ | ||
16 | +/* Hierarchial argument parsing, layered over getopt. | ||
17 | + Copyright (C) 1995-1999, 2003, 2004, 2005, 2006, 2007, 2009 | ||
18 | + Free Software Foundation, Inc. | ||
19 | + This file is part of the GNU C Library. | ||
20 | + Written by Miles Bader <miles at gnu.ai.mit.edu>. | ||
21 | + | ||
22 | + The GNU C Library is free software; you can redistribute it and/or | ||
23 | + modify it under the terms of the GNU Lesser General Public | ||
24 | + License as published by the Free Software Foundation; either | ||
25 | + version 2.1 of the License, or (at your option) any later version. | ||
26 | + | ||
27 | + The GNU C Library is distributed in the hope that it will be useful, | ||
28 | + but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
29 | + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
30 | + Lesser General Public License for more details. | ||
31 | + | ||
32 | + You should have received a copy of the GNU Lesser General Public | ||
33 | + License along with the GNU C Library; if not, write to the Free | ||
34 | + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | ||
35 | + 02111-1307 USA. | ||
36 | + | ||
37 | + Modified for uClibc by: Salvatore Cro <salvatore.cro at st.com> | ||
38 | +*/ | ||
39 | + | ||
40 | +#ifndef _ARGP_H | ||
41 | +#define _ARGP_H | ||
42 | + | ||
43 | +#include <stdio.h> | ||
44 | +#include <ctype.h> | ||
45 | +#include <limits.h> | ||
46 | + | ||
47 | +#define __need_error_t | ||
48 | +#include <errno.h> | ||
49 | + | ||
50 | +#ifndef __const | ||
51 | +# define __const const | ||
52 | +#endif | ||
53 | + | ||
54 | +#ifndef __THROW | ||
55 | +# define __THROW | ||
56 | +#endif | ||
57 | +#ifndef __NTH | ||
58 | +# define __NTH(fct) fct __THROW | ||
59 | +#endif | ||
60 | + | ||
61 | +#ifndef __attribute__ | ||
62 | +/* This feature is available in gcc versions 2.5 and later. */ | ||
63 | +# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || defined(__STRICT_ANSI__) | ||
64 | +# define __attribute__(Spec) /* empty */ | ||
65 | +# endif | ||
66 | +/* The __-protected variants of `format' and `printf' attributes | ||
67 | + are accepted by gcc versions 2.6.4 (effectively 2.7) and later. */ | ||
68 | +# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7) || defined(__STRICT_ANSI__) | ||
69 | +# define __format__ format | ||
70 | +# define __printf__ printf | ||
71 | +# endif | ||
72 | +#endif | ||
73 | + | ||
74 | +/* GCC 2.95 and later have "__restrict"; C99 compilers have | ||
75 | + "restrict", and "configure" may have defined "restrict". */ | ||
76 | +#ifndef __restrict | ||
77 | +# if ! (2 < __GNUC__ || (2 == __GNUC__ && 95 <= __GNUC_MINOR__)) | ||
78 | +# if defined restrict || 199901L <= __STDC_VERSION__ | ||
79 | +# define __restrict restrict | ||
80 | +# else | ||
81 | +# define __restrict | ||
82 | +# endif | ||
83 | +# endif | ||
84 | +#endif | ||
85 | + | ||
86 | +#ifndef __error_t_defined | ||
87 | +typedef int error_t; | ||
88 | +# define __error_t_defined | ||
89 | +#endif | ||
90 | + | ||
91 | +#ifdef __cplusplus | ||
92 | +extern "C" { | ||
93 | +#endif | ||
94 | + | ||
95 | +/* A description of a particular option. A pointer to an array of | ||
96 | + these is passed in the OPTIONS field of an argp structure. Each option | ||
97 | + entry can correspond to one long option and/or one short option; more | ||
98 | + names for the same option can be added by following an entry in an option | ||
99 | + array with options having the OPTION_ALIAS flag set. */ | ||
100 | +struct argp_option | ||
101 | +{ | ||
102 | + /* The long option name. For more than one name for the same option, you | ||
103 | + can use following options with the OPTION_ALIAS flag set. */ | ||
104 | + __const char *name; | ||
105 | + | ||
106 | + /* What key is returned for this option. If > 0 and printable, then it's | ||
107 | + also accepted as a short option. */ | ||
108 | + int key; | ||
109 | + | ||
110 | + /* If non-NULL, this is the name of the argument associated with this | ||
111 | + option, which is required unless the OPTION_ARG_OPTIONAL flag is set. */ | ||
112 | + __const char *arg; | ||
113 | + | ||
114 | + /* OPTION_ flags. */ | ||
115 | + int flags; | ||
116 | + | ||
117 | + /* The doc string for this option. If both NAME and KEY are 0, This string | ||
118 | + will be printed outdented from the normal option column, making it | ||
119 | + useful as a group header (it will be the first thing printed in its | ||
120 | + group); in this usage, it's conventional to end the string with a `:'. */ | ||
121 | + __const char *doc; | ||
122 | + | ||
123 | + /* The group this option is in. In a long help message, options are sorted | ||
124 | + alphabetically within each group, and the groups presented in the order | ||
125 | + 0, 1, 2, ..., n, -m, ..., -2, -1. Every entry in an options array with | ||
126 | + if this field 0 will inherit the group number of the previous entry, or | ||
127 | + zero if it's the first one, unless its a group header (NAME and KEY both | ||
128 | + 0), in which case, the previous entry + 1 is the default. Automagic | ||
129 | + options such as --help are put into group -1. */ | ||
130 | + int group; | ||
131 | +}; | ||
132 | + | ||
133 | +/* The argument associated with this option is optional. */ | ||
134 | +#define OPTION_ARG_OPTIONAL 0x1 | ||
135 | + | ||
136 | +/* This option isn't displayed in any help messages. */ | ||
137 | +#define OPTION_HIDDEN 0x2 | ||
138 | + | ||
139 | +/* This option is an alias for the closest previous non-alias option. This | ||
140 | + means that it will be displayed in the same help entry, and will inherit | ||
141 | + fields other than NAME and KEY from the aliased option. */ | ||
142 | +#define OPTION_ALIAS 0x4 | ||
143 | + | ||
144 | +/* This option isn't actually an option (and so should be ignored by the | ||
145 | + actual option parser), but rather an arbitrary piece of documentation that | ||
146 | + should be displayed in much the same manner as the options. If this flag | ||
147 | + is set, then the option NAME field is displayed unmodified (e.g., no `--' | ||
148 | + prefix is added) at the left-margin (where a *short* option would normally | ||
149 | + be displayed), and the documentation string in the normal place. For | ||
150 | + purposes of sorting, any leading whitespace and punctuation is ignored, | ||
151 | + except that if the first non-whitespace character is not `-', this entry | ||
152 | + is displayed after all options (and OPTION_DOC entries with a leading `-') | ||
153 | + in the same group. */ | ||
154 | +#define OPTION_DOC 0x8 | ||
155 | + | ||
156 | +/* This option shouldn't be included in `long' usage messages (but is still | ||
157 | + included in help messages). This is mainly intended for options that are | ||
158 | + completely documented in an argp's ARGS_DOC field, in which case including | ||
159 | + the option in the generic usage list would be redundant. For instance, | ||
160 | + if ARGS_DOC is "FOO BAR\n-x BLAH", and the `-x' option's purpose is to | ||
161 | + distinguish these two cases, -x should probably be marked | ||
162 | + OPTION_NO_USAGE. */ | ||
163 | +#define OPTION_NO_USAGE 0x10 | ||
164 | + | ||
165 | +struct argp; /* fwd declare this type */ | ||
166 | +struct argp_state; /* " */ | ||
167 | +struct argp_child; /* " */ | ||
168 | + | ||
169 | +/* The type of a pointer to an argp parsing function. */ | ||
170 | +typedef error_t (*argp_parser_t) (int __key, char *__arg, | ||
171 | + struct argp_state *__state); | ||
172 | + | ||
173 | +/* What to return for unrecognized keys. For special ARGP_KEY_ keys, such | ||
174 | + returns will simply be ignored. For user keys, this error will be turned | ||
175 | + into EINVAL (if the call to argp_parse is such that errors are propagated | ||
176 | + back to the user instead of exiting); returning EINVAL itself would result | ||
177 | + in an immediate stop to parsing in *all* cases. */ | ||
178 | +#define ARGP_ERR_UNKNOWN E2BIG /* Hurd should never need E2BIG. XXX */ | ||
179 | + | ||
180 | +/* Special values for the KEY argument to an argument parsing function. | ||
181 | + ARGP_ERR_UNKNOWN should be returned if they aren't understood. | ||
182 | + | ||
183 | + The sequence of keys to a parsing function is either (where each | ||
184 | + uppercased word should be prefixed by `ARGP_KEY_' and opt is a user key): | ||
185 | + | ||
186 | + INIT opt... NO_ARGS END SUCCESS -- No non-option arguments at all | ||
187 | + or INIT (opt | ARG)... END SUCCESS -- All non-option args parsed | ||
188 | + or INIT (opt | ARG)... SUCCESS -- Some non-option arg unrecognized | ||
189 | + | ||
190 | + The third case is where every parser returned ARGP_KEY_UNKNOWN for an | ||
191 | + argument, in which case parsing stops at that argument (returning the | ||
192 | + unparsed arguments to the caller of argp_parse if requested, or stopping | ||
193 | + with an error message if not). | ||
194 | + | ||
195 | + If an error occurs (either detected by argp, or because the parsing | ||
196 | + function returned an error value), then the parser is called with | ||
197 | + ARGP_KEY_ERROR, and no further calls are made. */ | ||
198 | + | ||
199 | +/* This is not an option at all, but rather a command line argument. If a | ||
200 | + parser receiving this key returns success, the fact is recorded, and the | ||
201 | + ARGP_KEY_NO_ARGS case won't be used. HOWEVER, if while processing the | ||
202 | + argument, a parser function decrements the NEXT field of the state it's | ||
203 | + passed, the option won't be considered processed; this is to allow you to | ||
204 | + actually modify the argument (perhaps into an option), and have it | ||
205 | + processed again. */ | ||
206 | +#define ARGP_KEY_ARG 0 | ||
207 | +/* There are remaining arguments not parsed by any parser, which may be found | ||
208 | + starting at (STATE->argv + STATE->next). If success is returned, but | ||
209 | + STATE->next left untouched, it's assumed that all arguments were consume, | ||
210 | + otherwise, the parser should adjust STATE->next to reflect any arguments | ||
211 | + consumed. */ | ||
212 | +#define ARGP_KEY_ARGS 0x1000006 | ||
213 | +/* There are no more command line arguments at all. */ | ||
214 | +#define ARGP_KEY_END 0x1000001 | ||
215 | +/* Because it's common to want to do some special processing if there aren't | ||
216 | + any non-option args, user parsers are called with this key if they didn't | ||
217 | + successfully process any non-option arguments. Called just before | ||
218 | + ARGP_KEY_END (where more general validity checks on previously parsed | ||
219 | + arguments can take place). */ | ||
220 | +#define ARGP_KEY_NO_ARGS 0x1000002 | ||
221 | +/* Passed in before any parsing is done. Afterwards, the values of each | ||
222 | + element of the CHILD_INPUT field, if any, in the state structure is | ||
223 | + copied to each child's state to be the initial value of the INPUT field. */ | ||
224 | +#define ARGP_KEY_INIT 0x1000003 | ||
225 | +/* Use after all other keys, including SUCCESS & END. */ | ||
226 | +#define ARGP_KEY_FINI 0x1000007 | ||
227 | +/* Passed in when parsing has successfully been completed (even if there are | ||
228 | + still arguments remaining). */ | ||
229 | +#define ARGP_KEY_SUCCESS 0x1000004 | ||
230 | +/* Passed in if an error occurs. */ | ||
231 | +#define ARGP_KEY_ERROR 0x1000005 | ||
232 | + | ||
233 | +/* An argp structure contains a set of options declarations, a function to | ||
234 | + deal with parsing one, documentation string, a possible vector of child | ||
235 | + argp's, and perhaps a function to filter help output. When actually | ||
236 | + parsing options, getopt is called with the union of all the argp | ||
237 | + structures chained together through their CHILD pointers, with conflicts | ||
238 | + being resolved in favor of the first occurrence in the chain. */ | ||
239 | +struct argp | ||
240 | +{ | ||
241 | + /* An array of argp_option structures, terminated by an entry with both | ||
242 | + NAME and KEY having a value of 0. */ | ||
243 | + __const struct argp_option *options; | ||
244 | + | ||
245 | + /* What to do with an option from this structure. KEY is the key | ||
246 | + associated with the option, and ARG is any associated argument (NULL if | ||
247 | + none was supplied). If KEY isn't understood, ARGP_ERR_UNKNOWN should be | ||
248 | + returned. If a non-zero, non-ARGP_ERR_UNKNOWN value is returned, then | ||
249 | + parsing is stopped immediately, and that value is returned from | ||
250 | + argp_parse(). For special (non-user-supplied) values of KEY, see the | ||
251 | + ARGP_KEY_ definitions below. */ | ||
252 | + argp_parser_t parser; | ||
253 | + | ||
254 | + /* A string describing what other arguments are wanted by this program. It | ||
255 | + is only used by argp_usage to print the `Usage:' message. If it | ||
256 | + contains newlines, the strings separated by them are considered | ||
257 | + alternative usage patterns, and printed on separate lines (lines after | ||
258 | + the first are prefix by ` or: ' instead of `Usage:'). */ | ||
259 | + __const char *args_doc; | ||
260 | + | ||
261 | + /* If non-NULL, a string containing extra text to be printed before and | ||
262 | + after the options in a long help message (separated by a vertical tab | ||
263 | + `\v' character). */ | ||
264 | + __const char *doc; | ||
265 | + | ||
266 | + /* A vector of argp_children structures, terminated by a member with a 0 | ||
267 | + argp field, pointing to child argps should be parsed with this one. Any | ||
268 | + conflicts are resolved in favor of this argp, or early argps in the | ||
269 | + CHILDREN list. This field is useful if you use libraries that supply | ||
270 | + their own argp structure, which you want to use in conjunction with your | ||
271 | + own. */ | ||
272 | + __const struct argp_child *children; | ||
273 | + | ||
274 | + /* If non-zero, this should be a function to filter the output of help | ||
275 | + messages. KEY is either a key from an option, in which case TEXT is | ||
276 | + that option's help text, or a special key from the ARGP_KEY_HELP_ | ||
277 | + defines, below, describing which other help text TEXT is. The function | ||
278 | + should return either TEXT, if it should be used as-is, a replacement | ||
279 | + string, which should be malloced, and will be freed by argp, or NULL, | ||
280 | + meaning `print nothing'. The value for TEXT is *after* any translation | ||
281 | + has been done, so if any of the replacement text also needs translation, | ||
282 | + that should be done by the filter function. INPUT is either the input | ||
283 | + supplied to argp_parse, or NULL, if argp_help was called directly. */ | ||
284 | + char *(*help_filter) (int __key, __const char *__text, void *__input); | ||
285 | + | ||
286 | + /* If non-zero the strings used in the argp library are translated using | ||
287 | + the domain described by this string. Otherwise the currently installed | ||
288 | + default domain is used. */ | ||
289 | + const char *argp_domain; | ||
290 | +}; | ||
291 | + | ||
292 | +/* Possible KEY arguments to a help filter function. */ | ||
293 | +#define ARGP_KEY_HELP_PRE_DOC 0x2000001 /* Help text preceeding options. */ | ||
294 | +#define ARGP_KEY_HELP_POST_DOC 0x2000002 /* Help text following options. */ | ||
295 | +#define ARGP_KEY_HELP_HEADER 0x2000003 /* Option header string. */ | ||
296 | +#define ARGP_KEY_HELP_EXTRA 0x2000004 /* After all other documentation; | ||
297 | + TEXT is NULL for this key. */ | ||
298 | +/* Explanatory note emitted when duplicate option arguments have been | ||
299 | + suppressed. */ | ||
300 | +#define ARGP_KEY_HELP_DUP_ARGS_NOTE 0x2000005 | ||
301 | +#define ARGP_KEY_HELP_ARGS_DOC 0x2000006 /* Argument doc string. */ | ||
302 | + | ||
303 | +/* When an argp has a non-zero CHILDREN field, it should point to a vector of | ||
304 | + argp_child structures, each of which describes a subsidiary argp. */ | ||
305 | +struct argp_child | ||
306 | +{ | ||
307 | + /* The child parser. */ | ||
308 | + __const struct argp *argp; | ||
309 | + | ||
310 | + /* Flags for this child. */ | ||
311 | + int flags; | ||
312 | + | ||
313 | + /* If non-zero, an optional header to be printed in help output before the | ||
314 | + child options. As a side-effect, a non-zero value forces the child | ||
315 | + options to be grouped together; to achieve this effect without actually | ||
316 | + printing a header string, use a value of "". */ | ||
317 | + __const char *header; | ||
318 | + | ||
319 | + /* Where to group the child options relative to the other (`consolidated') | ||
320 | + options in the parent argp; the values are the same as the GROUP field | ||
321 | + in argp_option structs, but all child-groupings follow parent options at | ||
322 | + a particular group level. If both this field and HEADER are zero, then | ||
323 | + they aren't grouped at all, but rather merged with the parent options | ||
324 | + (merging the child's grouping levels with the parents). */ | ||
325 | + int group; | ||
326 | +}; | ||
327 | + | ||
328 | +/* Parsing state. This is provided to parsing functions called by argp, | ||
329 | + which may examine and, as noted, modify fields. */ | ||
330 | +struct argp_state | ||
331 | +{ | ||
332 | + /* The top level ARGP being parsed. */ | ||
333 | + __const struct argp *root_argp; | ||
334 | + | ||
335 | + /* The argument vector being parsed. May be modified. */ | ||
336 | + int argc; | ||
337 | + char **argv; | ||
338 | + | ||
339 | + /* The index in ARGV of the next arg that to be parsed. May be modified. */ | ||
340 | + int next; | ||
341 | + | ||
342 | + /* The flags supplied to argp_parse. May be modified. */ | ||
343 | + unsigned flags; | ||
344 | + | ||
345 | + /* While calling a parsing function with a key of ARGP_KEY_ARG, this is the | ||
346 | + number of the current arg, starting at zero, and incremented after each | ||
347 | + such call returns. At all other times, this is the number of such | ||
348 | + arguments that have been processed. */ | ||
349 | + unsigned arg_num; | ||
350 | + | ||
351 | + /* If non-zero, the index in ARGV of the first argument following a special | ||
352 | + `--' argument (which prevents anything following being interpreted as an | ||
353 | + option). Only set once argument parsing has proceeded past this point. */ | ||
354 | + int quoted; | ||
355 | + | ||
356 | + /* An arbitrary pointer passed in from the user. */ | ||
357 | + void *input; | ||
358 | + /* Values to pass to child parsers. This vector will be the same length as | ||
359 | + the number of children for the current parser. */ | ||
360 | + void **child_inputs; | ||
361 | + | ||
362 | + /* For the parser's use. Initialized to 0. */ | ||
363 | + void *hook; | ||
364 | + | ||
365 | + /* The name used when printing messages. This is initialized to ARGV[0], | ||
366 | + or PROGRAM_INVOCATION_NAME if that is unavailable. */ | ||
367 | + char *name; | ||
368 | + | ||
369 | + /* Streams used when argp prints something. */ | ||
370 | + FILE *err_stream; /* For errors; initialized to stderr. */ | ||
371 | + FILE *out_stream; /* For information; initialized to stdout. */ | ||
372 | + | ||
373 | + void *pstate; /* Private, for use by argp. */ | ||
374 | +}; | ||
375 | + | ||
376 | +/* Flags for argp_parse (note that the defaults are those that are | ||
377 | + convenient for program command line parsing): */ | ||
378 | + | ||
379 | +/* Don't ignore the first element of ARGV. Normally (and always unless | ||
380 | + ARGP_NO_ERRS is set) the first element of the argument vector is | ||
381 | + skipped for option parsing purposes, as it corresponds to the program name | ||
382 | + in a command line. */ | ||
383 | +#define ARGP_PARSE_ARGV0 0x01 | ||
384 | + | ||
385 | +/* Don't print error messages for unknown options to stderr; unless this flag | ||
386 | + is set, ARGP_PARSE_ARGV0 is ignored, as ARGV[0] is used as the program | ||
387 | + name in the error messages. This flag implies ARGP_NO_EXIT (on the | ||
388 | + assumption that silent exiting upon errors is bad behaviour). */ | ||
389 | +#define ARGP_NO_ERRS 0x02 | ||
390 | + | ||
391 | +/* Don't parse any non-option args. Normally non-option args are parsed by | ||
392 | + calling the parse functions with a key of ARGP_KEY_ARG, and the actual arg | ||
393 | + as the value. Since it's impossible to know which parse function wants to | ||
394 | + handle it, each one is called in turn, until one returns 0 or an error | ||
395 | + other than ARGP_ERR_UNKNOWN; if an argument is handled by no one, the | ||
396 | + argp_parse returns prematurely (but with a return value of 0). If all | ||
397 | + args have been parsed without error, all parsing functions are called one | ||
398 | + last time with a key of ARGP_KEY_END. This flag needn't normally be set, | ||
399 | + as the normal behavior is to stop parsing as soon as some argument can't | ||
400 | + be handled. */ | ||
401 | +#define ARGP_NO_ARGS 0x04 | ||
402 | + | ||
403 | +/* Parse options and arguments in the same order they occur on the command | ||
404 | + line -- normally they're rearranged so that all options come first. */ | ||
405 | +#define ARGP_IN_ORDER 0x08 | ||
406 | + | ||
407 | +/* Don't provide the standard long option --help, which causes usage and | ||
408 | + option help information to be output to stdout, and exit (0) called. */ | ||
409 | +#define ARGP_NO_HELP 0x10 | ||
410 | + | ||
411 | +/* Don't exit on errors (they may still result in error messages). */ | ||
412 | +#define ARGP_NO_EXIT 0x20 | ||
413 | + | ||
414 | +/* Use the gnu getopt `long-only' rules for parsing arguments. */ | ||
415 | +#define ARGP_LONG_ONLY 0x40 | ||
416 | + | ||
417 | +/* Turns off any message-printing/exiting options. */ | ||
418 | +#define ARGP_SILENT (ARGP_NO_EXIT | ARGP_NO_ERRS | ARGP_NO_HELP) | ||
419 | + | ||
420 | +/* Parse the options strings in ARGC & ARGV according to the options in ARGP. | ||
421 | + FLAGS is one of the ARGP_ flags above. If ARG_INDEX is non-NULL, the | ||
422 | + index in ARGV of the first unparsed option is returned in it. If an | ||
423 | + unknown option is present, ARGP_ERR_UNKNOWN is returned; if some parser | ||
424 | + routine returned a non-zero value, it is returned; otherwise 0 is | ||
425 | + returned. This function may also call exit unless the ARGP_NO_HELP flag | ||
426 | + is set. INPUT is a pointer to a value to be passed in to the parser. */ | ||
427 | +extern error_t argp_parse (__const struct argp *__restrict __argp, | ||
428 | + int __argc, char **__restrict __argv, | ||
429 | + unsigned __flags, int *__restrict __arg_index, | ||
430 | + void *__restrict __input); | ||
431 | + | ||
432 | +/* Global variables. */ | ||
433 | + | ||
434 | +/* If defined or set by the user program to a non-zero value, then a default | ||
435 | + option --version is added (unless the ARGP_NO_HELP flag is used), which | ||
436 | + will print this string followed by a newline and exit (unless the | ||
437 | + ARGP_NO_EXIT flag is used). Overridden by ARGP_PROGRAM_VERSION_HOOK. */ | ||
438 | +extern __const char *argp_program_version; | ||
439 | + | ||
440 | +/* If defined or set by the user program to a non-zero value, then a default | ||
441 | + option --version is added (unless the ARGP_NO_HELP flag is used), which | ||
442 | + calls this function with a stream to print the version to and a pointer to | ||
443 | + the current parsing state, and then exits (unless the ARGP_NO_EXIT flag is | ||
444 | + used). This variable takes precedent over ARGP_PROGRAM_VERSION. */ | ||
445 | +extern void (*argp_program_version_hook) (FILE *__restrict __stream, | ||
446 | + struct argp_state *__restrict | ||
447 | + __state); | ||
448 | + | ||
449 | +/* If defined or set by the user program, it should point to string that is | ||
450 | + the bug-reporting address for the program. It will be printed by | ||
451 | + argp_help if the ARGP_HELP_BUG_ADDR flag is set (as it is by various | ||
452 | + standard help messages), embedded in a sentence that says something like | ||
453 | + `Report bugs to ADDR.'. */ | ||
454 | +extern __const char *argp_program_bug_address; | ||
455 | + | ||
456 | +/* The exit status that argp will use when exiting due to a parsing error. | ||
457 | + If not defined or set by the user program, this defaults to EX_USAGE from | ||
458 | + <sysexits.h>. */ | ||
459 | +extern error_t argp_err_exit_status; | ||
460 | + | ||
461 | +/* Flags for argp_help. */ | ||
462 | +#define ARGP_HELP_USAGE 0x01 /* a Usage: message. */ | ||
463 | +#define ARGP_HELP_SHORT_USAGE 0x02 /* " but don't actually print options. */ | ||
464 | +#define ARGP_HELP_SEE 0x04 /* a `Try ... for more help' message. */ | ||
465 | +#define ARGP_HELP_LONG 0x08 /* a long help message. */ | ||
466 | +#define ARGP_HELP_PRE_DOC 0x10 /* doc string preceding long help. */ | ||
467 | +#define ARGP_HELP_POST_DOC 0x20 /* doc string following long help. */ | ||
468 | +#define ARGP_HELP_DOC (ARGP_HELP_PRE_DOC | ARGP_HELP_POST_DOC) | ||
469 | +#define ARGP_HELP_BUG_ADDR 0x40 /* bug report address */ | ||
470 | +#define ARGP_HELP_LONG_ONLY 0x80 /* modify output appropriately to | ||
471 | + reflect ARGP_LONG_ONLY mode. */ | ||
472 | + | ||
473 | +/* These ARGP_HELP flags are only understood by argp_state_help. */ | ||
474 | +#define ARGP_HELP_EXIT_ERR 0x100 /* Call exit(1) instead of returning. */ | ||
475 | +#define ARGP_HELP_EXIT_OK 0x200 /* Call exit(0) instead of returning. */ | ||
476 | + | ||
477 | +/* The standard thing to do after a program command line parsing error, if an | ||
478 | + error message has already been printed. */ | ||
479 | +#define ARGP_HELP_STD_ERR \ | ||
480 | + (ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR) | ||
481 | +/* The standard thing to do after a program command line parsing error, if no | ||
482 | + more specific error message has been printed. */ | ||
483 | +#define ARGP_HELP_STD_USAGE \ | ||
484 | + (ARGP_HELP_SHORT_USAGE | ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR) | ||
485 | +/* The standard thing to do in response to a --help option. */ | ||
486 | +#define ARGP_HELP_STD_HELP \ | ||
487 | + (ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG | ARGP_HELP_EXIT_OK \ | ||
488 | + | ARGP_HELP_DOC | ARGP_HELP_BUG_ADDR) | ||
489 | + | ||
490 | +/* Output a usage message for ARGP to STREAM. FLAGS are from the set | ||
491 | + ARGP_HELP_*. */ | ||
492 | +extern void argp_help (__const struct argp *__restrict __argp, | ||
493 | + FILE *__restrict __stream, | ||
494 | + unsigned __flags, char *__restrict __name); | ||
495 | + | ||
496 | +/* The following routines are intended to be called from within an argp | ||
497 | + parsing routine (thus taking an argp_state structure as the first | ||
498 | + argument). They may or may not print an error message and exit, depending | ||
499 | + on the flags in STATE -- in any case, the caller should be prepared for | ||
500 | + them *not* to exit, and should return an appropiate error after calling | ||
501 | + them. [argp_usage & argp_error should probably be called argp_state_..., | ||
502 | + but they're used often enough that they should be short] */ | ||
503 | + | ||
504 | +/* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are | ||
505 | + from the set ARGP_HELP_*. */ | ||
506 | +extern void argp_state_help (__const struct argp_state *__restrict __state, | ||
507 | + FILE *__restrict __stream, | ||
508 | + unsigned int __flags); | ||
509 | +/* Possibly output the standard usage message for ARGP to stderr and exit. */ | ||
510 | +extern void argp_usage (__const struct argp_state *__state); | ||
511 | + | ||
512 | +/* If appropriate, print the printf string FMT and following args, preceded | ||
513 | + by the program name and `:', to stderr, and followed by a `Try ... --help' | ||
514 | + message, then exit (1). */ | ||
515 | +extern void argp_error (__const struct argp_state *__restrict __state, | ||
516 | + __const char *__restrict __fmt, ...) | ||
517 | + __attribute__ ((__format__ (__printf__, 2, 3))); | ||
518 | +/* Similar to the standard gnu error-reporting function error(), but will | ||
519 | + respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print | ||
520 | + to STATE->err_stream. This is useful for argument parsing code that is | ||
521 | + shared between program startup (when exiting is desired) and runtime | ||
522 | + option parsing (when typically an error code is returned instead). The | ||
523 | + difference between this function and argp_error is that the latter is for | ||
524 | + *parsing errors*, and the former is for other problems that occur during | ||
525 | + parsing but don't reflect a (syntactic) problem with the input. */ | ||
526 | +extern void argp_failure (__const struct argp_state *__restrict __state, | ||
527 | + int __status, int __errnum, | ||
528 | + __const char *__restrict __fmt, ...) | ||
529 | + __attribute__ ((__format__ (__printf__, 4, 5))); | ||
530 | +/* Returns true if the option OPT is a valid short option. */ | ||
531 | +extern int _option_is_short (__const struct argp_option *__opt) __THROW; | ||
532 | +extern int __option_is_short (__const struct argp_option *__opt) __THROW; | ||
533 | + | ||
534 | +/* Returns true if the option OPT is in fact the last (unused) entry in an | ||
535 | + options array. */ | ||
536 | +extern int _option_is_end (__const struct argp_option *__opt) __THROW; | ||
537 | +extern int __option_is_end (__const struct argp_option *__opt) __THROW; | ||
538 | + | ||
539 | +/* Return the input field for ARGP in the parser corresponding to STATE; used | ||
540 | + by the help routines. */ | ||
541 | +/* We think this should not be exported */ | ||
542 | +extern void *__argp_input (__const struct argp *__restrict __argp, | ||
543 | + __const struct argp_state *__restrict __state) | ||
544 | + __THROW; | ||
545 | + | ||
546 | +#ifdef __USE_EXTERN_INLINES | ||
547 | + | ||
548 | +# ifndef ARGP_EI | ||
549 | +# define ARGP_EI __extern_inline | ||
550 | +# endif | ||
551 | + | ||
552 | +ARGP_EI void | ||
553 | +argp_usage (__const struct argp_state *__state) | ||
554 | +{ | ||
555 | + argp_state_help (__state, stderr, ARGP_HELP_STD_USAGE); | ||
556 | +} | ||
557 | + | ||
558 | +ARGP_EI int | ||
559 | +__NTH (__option_is_short (__const struct argp_option *__opt)) | ||
560 | +{ | ||
561 | + if (__opt->flags & OPTION_DOC) | ||
562 | + return 0; | ||
563 | + else | ||
564 | + { | ||
565 | + int __key = __opt->key; | ||
566 | + return __key > 0 && __key <= UCHAR_MAX && isprint (__key); | ||
567 | + } | ||
568 | +} | ||
569 | + | ||
570 | +ARGP_EI int | ||
571 | +__NTH (__option_is_end (__const struct argp_option *__opt)) | ||
572 | +{ | ||
573 | + return !__opt->key && !__opt->name && !__opt->doc && !__opt->group; | ||
574 | +} | ||
575 | +#endif /* Use extern inlines. */ | ||
576 | + | ||
577 | +#ifdef __cplusplus | ||
578 | +} | ||
579 | +#endif | ||
580 | + | ||
581 | +#endif /* argp.h */ | ||