Skip to content

John McEleney / mailutils

Go to a project
Toggle navigation
Toggle navigation pinning
Commit b40d6cda b40d6cda037293750fb1c42aa09faa82242c64d0 by Sergey Poznyakoff
Options

Moved to /headers

1 parent 7fc7cbb1
Inline Side-by-side
Showing 4 changed files with 0 additions and 1348 deletions
1 /* Hierarchial argument parsing, layered over getopt.
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2001 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Written by Miles Bader <miles@gnu.ai.mit.edu>.
5
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.
10
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.
15
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. */
20
21 #ifndef _ARGP_H
22 #define _ARGP_H
23
24 #include <stdio.h>
25 #include <ctype.h>
26 #ifdef HAVE_GETOPT_H
27 # include <getopt.h>
28 #else
29 # include <mailutils/gnu/getopt.h>
30 #endif
31
32
33 #define __need_error_t
34 #include <errno.h>
35
36 #ifndef __error_t_defined
37 typedef int error_t;
38 # define __error_t_defined
39 #endif
40
41 /* My libc doesn't have these. -mccallum@jprc.com */
42 #ifndef HAVE_PROGRAM_INVOCATION_NAME
43 extern char *program_invocation_short_name;
44 extern char *program_invocation_name;
45 #endif
46
47 #ifdef __cplusplus
48 extern "C" {
49 #endif
50
51 /* A description of a particular option. A pointer to an array of
52 these is passed in the OPTIONS field of an argp structure. Each option
53 entry can correspond to one long option and/or one short option; more
54 names for the same option can be added by following an entry in an option
55 array with options having the OPTION_ALIAS flag set. */
56 struct argp_option
57 {
58 /* The long option name. For more than one name for the same option, you
59 can use following options with the OPTION_ALIAS flag set. */
60 const char *name;
61
62 /* What key is returned for this option. If > 0 and printable, then it's
63 also accepted as a short option. */
64 int key;
65
66 /* If non-NULL, this is the name of the argument associated with this
67 option, which is required unless the OPTION_ARG_OPTIONAL flag is set. */
68 const char *arg;
69
70 /* OPTION_ flags. */
71 int flags;
72
73 /* The doc string for this option. If both NAME and KEY are 0, This string
74 will be printed outdented from the normal option column, making it
75 useful as a group header (it will be the first thing printed in its
76 group); in this usage, it's conventional to end the string with a `:'. */
77 const char *doc;
78
79 /* The group this option is in. In a long help message, options are sorted
80 alphabetically within each group, and the groups presented in the order
81 0, 1, 2, ..., n, -m, ..., -2, -1. Every entry in an options array with
82 if this field 0 will inherit the group number of the previous entry, or
83 zero if it's the first one, unless its a group header (NAME and KEY both
84 0), in which case, the previous entry + 1 is the default. Automagic
85 options such as --help are put into group -1. */
86 int group;
87 };
88
89 /* The argument associated with this option is optional. */
90 #define OPTION_ARG_OPTIONAL 0x1
91
92 /* This option isn't displayed in any help messages. */
93 #define OPTION_HIDDEN 0x2
94
95 /* This option is an alias for the closest previous non-alias option. This
96 means that it will be displayed in the same help entry, and will inherit
97 fields other than NAME and KEY from the aliased option. */
98 #define OPTION_ALIAS 0x4
99
100 /* This option isn't actually an option (and so should be ignored by the
101 actual option parser), but rather an arbitrary piece of documentation that
102 should be displayed in much the same manner as the options. If this flag
103 is set, then the option NAME field is displayed unmodified (e.g., no `--'
104 prefix is added) at the left-margin (where a *short* option would normally
105 be displayed), and the documentation string in the normal place. For
106 purposes of sorting, any leading whitespace and puncuation is ignored,
107 except that if the first non-whitespace character is not `-', this entry
108 is displayed after all options (and OPTION_DOC entries with a leading `-')
109 in the same group. */
110 #define OPTION_DOC 0x8
111
112 /* This option shouldn't be included in `long' usage messages (but is still
113 included in help messages). This is mainly intended for options that are
114 completely documented in an argp's ARGS_DOC field, in which case including
115 the option in the generic usage list would be redundant. For instance,
116 if ARGS_DOC is "FOO BAR\n-x BLAH", and the `-x' option's purpose is to
117 distinguish these two cases, -x should probably be marked
118 OPTION_NO_USAGE. */
119 #define OPTION_NO_USAGE 0x10
120
121 struct argp; /* fwd declare this type */
122 struct argp_state; /* " */
123 struct argp_child; /* " */
124
125 /* The type of a pointer to an argp parsing function. */
126 typedef error_t (*argp_parser_t) (int key, char *arg,
127 struct argp_state *state);
128
129 /* What to return for unrecognized keys. For special ARGP_KEY_ keys, such
130 returns will simply be ignored. For user keys, this error will be turned
131 into EINVAL (if the call to argp_parse is such that errors are propagated
132 back to the user instead of exiting); returning EINVAL itself would result
133 in an immediate stop to parsing in *all* cases. */
134 #define ARGP_ERR_UNKNOWN E2BIG /* Hurd should never need E2BIG. XXX */
135
136 /* Special values for the KEY argument to an argument parsing function.
137 ARGP_ERR_UNKNOWN should be returned if they aren't understood.
138
139 The sequence of keys to a parsing function is either (where each
140 uppercased word should be prefixed by `ARGP_KEY_' and opt is a user key):
141
142 INIT opt... NO_ARGS END SUCCESS -- No non-option arguments at all
143 or INIT (opt | ARG)... END SUCCESS -- All non-option args parsed
144 or INIT (opt | ARG)... SUCCESS -- Some non-option arg unrecognized
145
146 The third case is where every parser returned ARGP_KEY_UNKNOWN for an
147 argument, in which case parsing stops at that argument (returning the
148 unparsed arguments to the caller of argp_parse if requested, or stopping
149 with an error message if not).
150
151 If an error occurs (either detected by argp, or because the parsing
152 function returned an error value), then the parser is called with
153 ARGP_KEY_ERROR, and no further calls are made. */
154
155 /* This is not an option at all, but rather a command line argument. If a
156 parser receiving this key returns success, the fact is recorded, and the
157 ARGP_KEY_NO_ARGS case won't be used. HOWEVER, if while processing the
158 argument, a parser function decrements the NEXT field of the state it's
159 passed, the option won't be considered processed; this is to allow you to
160 actually modify the argument (perhaps into an option), and have it
161 processed again. */
162 #define ARGP_KEY_ARG 0
163 /* There are remaining arguments not parsed by any parser, which may be found
164 starting at (STATE->argv + STATE->next). If success is returned, but
165 STATE->next left untouched, it's assumed that all arguments were consume,
166 otherwise, the parser should adjust STATE->next to reflect any arguments
167 consumed. */
168 #define ARGP_KEY_ARGS 0x1000006
169 /* There are no more command line arguments at all. */
170 #define ARGP_KEY_END 0x1000001
171 /* Because it's common to want to do some special processing if there aren't
172 any non-option args, user parsers are called with this key if they didn't
173 successfully process any non-option arguments. Called just before
174 ARGP_KEY_END (where more general validity checks on previously parsed
175 arguments can take place). */
176 #define ARGP_KEY_NO_ARGS 0x1000002
177 /* Passed in before any parsing is done. Afterwards, the values of each
178 element of the CHILD_INPUT field, if any, in the state structure is
179 copied to each child's state to be the initial value of the INPUT field. */
180 #define ARGP_KEY_INIT 0x1000003
181 /* Use after all other keys, including SUCCESS & END. */
182 #define ARGP_KEY_FINI 0x1000007
183 /* Passed in when parsing has successfully been completed (even if there are
184 still arguments remaining). */
185 #define ARGP_KEY_SUCCESS 0x1000004
186 /* Passed in if an error occurs. */
187 #define ARGP_KEY_ERROR 0x1000005
188
189 /* An argp structure contains a set of options declarations, a function to
190 deal with parsing one, documentation string, a possible vector of child
191 argp's, and perhaps a function to filter help output. When actually
192 parsing options, getopt is called with the union of all the argp
193 structures chained together through their CHILD pointers, with conflicts
194 being resolved in favor of the first occurrence in the chain. */
195 struct argp
196 {
197 /* An array of argp_option structures, terminated by an entry with both
198 NAME and KEY having a value of 0. */
199 const struct argp_option *options;
200
201 /* What to do with an option from this structure. KEY is the key
202 associated with the option, and ARG is any associated argument (NULL if
203 none was supplied). If KEY isn't understood, ARGP_ERR_UNKNOWN should be
204 returned. If a non-zero, non-ARGP_ERR_UNKNOWN value is returned, then
205 parsing is stopped immediately, and that value is returned from
206 argp_parse(). For special (non-user-supplied) values of KEY, see the
207 ARGP_KEY_ definitions below. */
208 argp_parser_t parser;
209
210 /* A string describing what other arguments are wanted by this program. It
211 is only used by argp_usage to print the `Usage:' message. If it
212 contains newlines, the strings separated by them are considered
213 alternative usage patterns, and printed on separate lines (lines after
214 the first are prefix by ` or: ' instead of `Usage:'). */
215 const char *args_doc;
216
217 /* If non-NULL, a string containing extra text to be printed before and
218 after the options in a long help message (separated by a vertical tab
219 `\v' character). */
220 const char *doc;
221
222 /* A vector of argp_children structures, terminated by a member with a 0
223 argp field, pointing to child argps should be parsed with this one. Any
224 conflicts are resolved in favor of this argp, or early argps in the
225 CHILDREN list. This field is useful if you use libraries that supply
226 their own argp structure, which you want to use in conjunction with your
227 own. */
228 const struct argp_child *children;
229
230 /* If non-zero, this should be a function to filter the output of help
231 messages. KEY is either a key from an option, in which case TEXT is
232 that option's help text, or a special key from the ARGP_KEY_HELP_
233 defines, below, describing which other help text TEXT is. The function
234 should return either TEXT, if it should be used as-is, a replacement
235 string, which should be malloced, and will be freed by argp, or NULL,
236 meaning `print nothing'. The value for TEXT is *after* any translation
237 has been done, so if any of the replacement text also needs translation,
238 that should be done by the filter function. INPUT is either the input
239 supplied to argp_parse, or NULL, if argp_help was called directly. */
240 char *(*help_filter) (int __key, const char *__text, void *__input);
241
242 /* If non-zero the strings used in the argp library are translated using
243 the domain described by this string. Otherwise the currently installed
244 default domain is used. */
245 const char *argp_domain;
246 };
247
248 /* Possible KEY arguments to a help filter function. */
249 #define ARGP_KEY_HELP_PRE_DOC 0x2000001 /* Help text preceeding options. */
250 #define ARGP_KEY_HELP_POST_DOC 0x2000002 /* Help text following options. */
251 #define ARGP_KEY_HELP_HEADER 0x2000003 /* Option header string. */
252 #define ARGP_KEY_HELP_EXTRA 0x2000004 /* After all other documentation;
253 TEXT is NULL for this key. */
254 /* Explanatory note emitted when duplicate option arguments have been
255 suppressed. */
256 #define ARGP_KEY_HELP_DUP_ARGS_NOTE 0x2000005
257 #define ARGP_KEY_HELP_ARGS_DOC 0x2000006 /* Argument doc string. */
258
259 /* When an argp has a non-zero CHILDREN field, it should point to a vector of
260 argp_child structures, each of which describes a subsidiary argp. */
261 struct argp_child
262 {
263 /* The child parser. */
264 const struct argp *argp;
265
266 /* Flags for this child. */
267 int flags;
268
269 /* If non-zero, an optional header to be printed in help output before the
270 child options. As a side-effect, a non-zero value forces the child
271 options to be grouped together; to achieve this effect without actually
272 printing a header string, use a value of "". */
273 const char *header;
274
275 /* Where to group the child options relative to the other (`consolidated')
276 options in the parent argp; the values are the same as the GROUP field
277 in argp_option structs, but all child-groupings follow parent options at
278 a particular group level. If both this field and HEADER are zero, then
279 they aren't grouped at all, but rather merged with the parent options
280 (merging the child's grouping levels with the parents). */
281 int group;
282 };
283
284 /* Parsing state. This is provided to parsing functions called by argp,
285 which may examine and, as noted, modify fields. */
286 struct argp_state
287 {
288 /* The top level ARGP being parsed. */
289 const struct argp *root_argp;
290
291 /* The argument vector being parsed. May be modified. */
292 int argc;
293 char **argv;
294
295 /* The index in ARGV of the next arg that to be parsed. May be modified. */
296 int next;
297
298 /* The flags supplied to argp_parse. May be modified. */
299 unsigned flags;
300
301 /* While calling a parsing function with a key of ARGP_KEY_ARG, this is the
302 number of the current arg, starting at zero, and incremented after each
303 such call returns. At all other times, this is the number of such
304 arguments that have been processed. */
305 unsigned arg_num;
306
307 /* If non-zero, the index in ARGV of the first argument following a special
308 `--' argument (which prevents anything following being interpreted as an
309 option). Only set once argument parsing has proceeded past this point. */
310 int quoted;
311
312 /* An arbitrary pointer passed in from the user. */
313 void *input;
314 /* Values to pass to child parsers. This vector will be the same length as
315 the number of children for the current parser. */
316 void **child_inputs;
317
318 /* For the parser's use. Initialized to 0. */
319 void *hook;
320
321 /* The name used when printing messages. This is initialized to ARGV[0],
322 or PROGRAM_INVOCATION_NAME if that is unavailable. */
323 char *name;
324
325 /* Streams used when argp prints something. */
326 FILE *err_stream; /* For errors; initialized to stderr. */
327 FILE *out_stream; /* For information; initialized to stdout. */
328
329 void *pstate; /* Private, for use by argp. */
330 };
331
332 /* Flags for argp_parse (note that the defaults are those that are
333 convenient for program command line parsing): */
334
335 /* Don't ignore the first element of ARGV. Normally (and always unless
336 ARGP_NO_ERRS is set) the first element of the argument vector is
337 skipped for option parsing purposes, as it corresponds to the program name
338 in a command line. */
339 #define ARGP_PARSE_ARGV0 0x01
340
341 /* Don't print error messages for unknown options to stderr; unless this flag
342 is set, ARGP_PARSE_ARGV0 is ignored, as ARGV[0] is used as the program
343 name in the error messages. This flag implies ARGP_NO_EXIT (on the
344 assumption that silent exiting upon errors is bad behaviour). */
345 #define ARGP_NO_ERRS 0x02
346
347 /* Don't parse any non-option args. Normally non-option args are parsed by
348 calling the parse functions with a key of ARGP_KEY_ARG, and the actual arg
349 as the value. Since it's impossible to know which parse function wants to
350 handle it, each one is called in turn, until one returns 0 or an error
351 other than ARGP_ERR_UNKNOWN; if an argument is handled by no one, the
352 argp_parse returns prematurely (but with a return value of 0). If all
353 args have been parsed without error, all parsing functions are called one
354 last time with a key of ARGP_KEY_END. This flag needn't normally be set,
355 as the normal behavior is to stop parsing as soon as some argument can't
356 be handled. */
357 #define ARGP_NO_ARGS 0x04
358
359 /* Parse options and arguments in the same order they occur on the command
360 line -- normally they're rearranged so that all options come first. */
361 #define ARGP_IN_ORDER 0x08
362
363 /* Don't provide the standard long option --help, which causes usage and
364 option help information to be output to stdout, and exit (0) called. */
365 #define ARGP_NO_HELP 0x10
366
367 /* Don't exit on errors (they may still result in error messages). */
368 #define ARGP_NO_EXIT 0x20
369
370 /* Use the gnu getopt `long-only' rules for parsing arguments. */
371 #define ARGP_LONG_ONLY 0x40
372
373 /* Turns off any message-printing/exiting options. */
374 #define ARGP_SILENT (ARGP_NO_EXIT | ARGP_NO_ERRS | ARGP_NO_HELP)
375
376 /* Parse the options strings in ARGC & ARGV according to the options in ARGP.
377 FLAGS is one of the ARGP_ flags above. If ARG_INDEX is non-NULL, the
378 index in ARGV of the first unparsed option is returned in it. If an
379 unknown option is present, ARGP_ERR_UNKNOWN is returned; if some parser
380 routine returned a non-zero value, it is returned; otherwise 0 is
381 returned. This function may also call exit unless the ARGP_NO_HELP flag
382 is set. INPUT is a pointer to a value to be passed in to the parser. */
383 extern error_t argp_parse (const struct argp *__argp,
384 int __argc, char **__argv,
385 unsigned __flags, int *__arg_index,
386 void *__input);
387 extern error_t __argp_parse (const struct argp *__argp,
388 int __argc, char **__argv,
389 unsigned __flags, int *__arg_index,
390 void *__input);
391
392 /* Global variables. */
393
394 /* If defined or set by the user program to a non-zero value, then a default
395 option --version is added (unless the ARGP_NO_HELP flag is used), which
396 will print this string followed by a newline and exit (unless the
397 ARGP_NO_EXIT flag is used). Overridden by ARGP_PROGRAM_VERSION_HOOK. */
398 extern const char *argp_program_version;
399
400 /* If defined or set by the user program to a non-zero value, then a default
401 option --version is added (unless the ARGP_NO_HELP flag is used), which
402 calls this function with a stream to print the version to and a pointer to
403 the current parsing state, and then exits (unless the ARGP_NO_EXIT flag is
404 used). This variable takes precedent over ARGP_PROGRAM_VERSION. */
405 extern void (*argp_program_version_hook) (FILE *__stream,
406 struct argp_state *__state);
407
408 /* If defined or set by the user program, it should point to string that is
409 the bug-reporting address for the program. It will be printed by
410 argp_help if the ARGP_HELP_BUG_ADDR flag is set (as it is by various
411 standard help messages), embedded in a sentence that says something like
412 `Report bugs to ADDR.'. */
413 extern const char *argp_program_bug_address;
414
415 /* The exit status that argp will use when exiting due to a parsing error.
416 If not defined or set by the user program, this defaults to EX_USAGE from
417 <sysexits.h>. */
418 extern error_t argp_err_exit_status;
419
420 /* Flags for argp_help. */
421 #define ARGP_HELP_USAGE 0x01 /* a Usage: message. */
422 #define ARGP_HELP_SHORT_USAGE 0x02 /* " but don't actually print options. */
423 #define ARGP_HELP_SEE 0x04 /* a `Try ... for more help' message. */
424 #define ARGP_HELP_LONG 0x08 /* a long help message. */
425 #define ARGP_HELP_PRE_DOC 0x10 /* doc string preceding long help. */
426 #define ARGP_HELP_POST_DOC 0x20 /* doc string following long help. */
427 #define ARGP_HELP_DOC (ARGP_HELP_PRE_DOC | ARGP_HELP_POST_DOC)
428 #define ARGP_HELP_BUG_ADDR 0x40 /* bug report address */
429 #define ARGP_HELP_LONG_ONLY 0x80 /* modify output appropriately to
430 reflect ARGP_LONG_ONLY mode. */
431
432 /* These ARGP_HELP flags are only understood by argp_state_help. */
433 #define ARGP_HELP_EXIT_ERR 0x100 /* Call exit(1) instead of returning. */
434 #define ARGP_HELP_EXIT_OK 0x200 /* Call exit(0) instead of returning. */
435
436 /* The standard thing to do after a program command line parsing error, if an
437 error message has already been printed. */
438 #define ARGP_HELP_STD_ERR \
439 (ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR)
440 /* The standard thing to do after a program command line parsing error, if no
441 more specific error message has been printed. */
442 #define ARGP_HELP_STD_USAGE \
443 (ARGP_HELP_SHORT_USAGE | ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR)
444 /* The standard thing to do in response to a --help option. */
445 #define ARGP_HELP_STD_HELP \
446 (ARGP_HELP_SHORT_USAGE | ARGP_HELP_LONG | ARGP_HELP_EXIT_OK \
447 | ARGP_HELP_DOC | ARGP_HELP_BUG_ADDR)
448
449 /* Output a usage message for ARGP to STREAM. FLAGS are from the set
450 ARGP_HELP_*. */
451 extern void argp_help (const struct argp *__argp,
452 FILE *__stream,
453 unsigned __flags, char *__name);
454 extern void __argp_help (const struct argp *__argp,
455 FILE *__stream, unsigned __flags,
456 char *__name);
457
458 /* The following routines are intended to be called from within an argp
459 parsing routine (thus taking an argp_state structure as the first
460 argument). They may or may not print an error message and exit, depending
461 on the flags in STATE -- in any case, the caller should be prepared for
462 them *not* to exit, and should return an appropiate error after calling
463 them. [argp_usage & argp_error should probably be called argp_state_...,
464 but they're used often enough that they should be short] */
465
466 /* Output, if appropriate, a usage message for STATE to STREAM. FLAGS are
467 from the set ARGP_HELP_*. */
468 extern void argp_state_help (const struct argp_state *__state,
469 FILE *__stream,
470 unsigned int __flags);
471 extern void __argp_state_help (const struct argp_state *__state,
472 FILE *__stream,
473 unsigned int __flags);
474
475 /* Possibly output the standard usage message for ARGP to stderr and exit. */
476 extern void argp_usage (const struct argp_state *__state);
477 extern void __argp_usage (const struct argp_state *__state);
478
479 /* If appropriate, print the printf string FMT and following args, preceded
480 by the program name and `:', to stderr, and followed by a `Try ... --help'
481 message, then exit (1). */
482 extern void argp_error (const struct argp_state *__state,
483 const char *__fmt, ...);
484 extern void __argp_error (const struct argp_state *__state,
485 const char *__fmt, ...);
486
487 /* Similar to the standard gnu error-reporting function error(), but will
488 respect the ARGP_NO_EXIT and ARGP_NO_ERRS flags in STATE, and will print
489 to STATE->err_stream. This is useful for argument parsing code that is
490 shared between program startup (when exiting is desired) and runtime
491 option parsing (when typically an error code is returned instead). The
492 difference between this function and argp_error is that the latter is for
493 *parsing errors*, and the former is for other problems that occur during
494 parsing but don't reflect a (syntactic) problem with the input. */
495 extern void argp_failure (const struct argp_state *__state,
496 int __status, int __errnum,
497 const char *__fmt, ...);
498 extern void __argp_failure (const struct argp_state *__state,
499 int __status, int __errnum,
500 const char *__fmt, ...);
501
502 /* Returns true if the option OPT is a valid short option. */
503 extern int _option_is_short (const struct argp_option *__opt);
504 extern int __option_is_short (const struct argp_option *__opt);
505
506 /* Returns true if the option OPT is in fact the last (unused) entry in an
507 options array. */
508 extern int _option_is_end (const struct argp_option *__opt);
509 extern int __option_is_end (const struct argp_option *__opt);
510
511 /* Return the input field for ARGP in the parser corresponding to STATE; used
512 by the help routines. */
513 extern void *_argp_input (const struct argp *__argp,
514 const struct argp_state *__state);
515 extern void *__argp_input (const struct argp *__argp,
516 const struct argp_state *__state);
517
518 #ifdef __USE_EXTERN_INLINES
519
520 # if !_LIBC
521 # define __argp_usage argp_usage
522 # define __argp_state_help argp_state_help
523 # define __option_is_short _option_is_short
524 # define __option_is_end _option_is_end
525 # endif
526
527 # ifndef ARGP_EI
528 # define ARGP_EI extern __inline__
529 # endif
530
531 ARGP_EI void
532 __argp_usage (const struct argp_state *__state)
533 {
534 __argp_state_help (__state, stderr, ARGP_HELP_STD_USAGE);
535 }
536
537 ARGP_EI int
538 __option_is_short (const struct argp_option *__opt)
539 {
540 if (__opt->flags & OPTION_DOC)
541 return 0;
542 else
543 {
544 int __key = __opt->key;
545 return __key > 0 && isprint (__key);
546 }
547 }
548
549 ARGP_EI int
550 __option_is_end (const struct argp_option *__opt)
551 {
552 return !__opt->key && !__opt->name && !__opt->doc && !__opt->group;
553 }
554
555 # if !_LIBC
556 # undef __argp_usage
557 # undef __argp_state_help
558 # undef __option_is_short
559 # undef __option_is_end
560 # endif
561 #endif /* Use extern inlines. */
562
563 #ifdef __cplusplus
564 }
565 #endif
566
567 #endif /* argp.h */
1 /* Declarations for getopt.
2 Copyright (C) 1989,90,91,92,93,94,96,97,98 Free Software Foundation, Inc.
3 NOTE: The canonical source of this file is maintained with the GNU C Library.
4 Bugs can be reported to bug-glibc@gnu.org.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any
8 later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
18 USA. */
19
20 #ifndef _GETOPT_H
21
22 #ifndef __need_getopt
23 # define _GETOPT_H 1
24 #endif
25
26 #ifdef __cplusplus
27 extern "C" {
28 #endif
29
30 /* For communication from `getopt' to the caller.
31 When `getopt' finds an option that takes an argument,
32 the argument value is returned here.
33 Also, when `ordering' is RETURN_IN_ORDER,
34 each non-option ARGV-element is returned here. */
35
36 extern char *optarg;
37
38 /* Index in ARGV of the next element to be scanned.
39 This is used for communication to and from the caller
40 and for communication between successive calls to `getopt'.
41
42 On entry to `getopt', zero means this is the first call; initialize.
43
44 When `getopt' returns -1, this is the index of the first of the
45 non-option elements that the caller should itself scan.
46
47 Otherwise, `optind' communicates from one call to the next
48 how much of ARGV has been scanned so far. */
49
50 extern int optind;
51
52 /* Callers store zero here to inhibit the error message `getopt' prints
53 for unrecognized options. */
54
55 extern int opterr;
56
57 /* Set to an option character which was unrecognized. */
58
59 extern int optopt;
60
61 #ifndef __need_getopt
62 /* Describe the long-named options requested by the application.
63 The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
64 of `struct option' terminated by an element containing a name which is
65 zero.
66
67 The field `has_arg' is:
68 no_argument (or 0) if the option does not take an argument,
69 required_argument (or 1) if the option requires an argument,
70 optional_argument (or 2) if the option takes an optional argument.
71
72 If the field `flag' is not NULL, it points to a variable that is set
73 to the value given in the field `val' when the option is found, but
74 left unchanged if the option is not found.
75
76 To have a long-named option do something other than set an `int' to
77 a compiled-in constant, such as set a value from `optarg', set the
78 option's `flag' field to zero and its `val' field to a nonzero
79 value (the equivalent single-letter option character, if there is
80 one). For long options that have a zero `flag' field, `getopt'
81 returns the contents of the `val' field. */
82
83 struct option
84 {
85 # if defined __STDC__ && __STDC__
86 const char *name;
87 # else
88 char *name;
89 # endif
90 /* has_arg can't be an enum because some compilers complain about
91 type mismatches in all the code that assumes it is an int. */
92 int has_arg;
93 int *flag;
94 int val;
95 };
96
97 /* Names for the values of the `has_arg' field of `struct option'. */
98
99 # define no_argument 0
100 # define required_argument 1
101 # define optional_argument 2
102 #endif /* need getopt */
103
104
105 /* Get definitions and prototypes for functions to process the
106 arguments in ARGV (ARGC of them, minus the program name) for
107 options given in OPTS.
108
109 Return the option character from OPTS just read. Return -1 when
110 there are no more options. For unrecognized options, or options
111 missing arguments, `optopt' is set to the option letter, and '?' is
112 returned.
113
114 The OPTS string is a list of characters which are recognized option
115 letters, optionally followed by colons, specifying that that letter
116 takes an argument, to be placed in `optarg'.
117
118 If a letter in OPTS is followed by two colons, its argument is
119 optional. This behavior is specific to the GNU `getopt'.
120
121 The argument `--' causes premature termination of argument
122 scanning, explicitly telling `getopt' that there are no more
123 options.
124
125 If OPTS begins with `--', then non-option arguments are treated as
126 arguments to the option '\0'. This behavior is specific to the GNU
127 `getopt'. */
128
129 #if defined __STDC__ && __STDC__
130 # ifdef __GNU_LIBRARY__
131 /* Many other libraries have conflicting prototypes for getopt, with
132 differences in the consts, in stdlib.h. To avoid compilation
133 errors, only prototype getopt for the GNU C library. */
134 extern int getopt (int __argc, char *const *__argv, const char *__shortopts);
135 # else /* not __GNU_LIBRARY__ */
136 extern int getopt ();
137 # endif /* __GNU_LIBRARY__ */
138
139 # ifndef __need_getopt
140 extern int getopt_long (int __argc, char *const *__argv, const char *__shortopts,
141 const struct option *__longopts, int *__longind);
142 extern int getopt_long_only (int __argc, char *const *__argv,
143 const char *__shortopts,
144 const struct option *__longopts, int *__longind);
145
146 /* Internal only. Users should not call this directly. */
147 extern int _getopt_internal (int __argc, char *const *__argv,
148 const char *__shortopts,
149 const struct option *__longopts, int *__longind,
150 int __long_only);
151 # endif
152 #else /* not __STDC__ */
153 extern int getopt ();
154 # ifndef __need_getopt
155 extern int getopt_long ();
156 extern int getopt_long_only ();
157
158 extern int _getopt_internal ();
159 # endif
160 #endif /* __STDC__ */
161
162 #ifdef __cplusplus
163 }
164 #endif
165
166 /* Make sure we later can get all the definitions and declarations. */
167 #undef __need_getopt
168
169 #endif /* getopt.h */
1 /* Definitions for data structures and routines for the regular
2 expression library, version 0.12.
3 Copyright (C) 1985,1989-1993,1995-1998, 2000 Free Software Foundation, Inc.
4
5 This file is part of the GNU C Library. Its master source is NOT part of
6 the C library, however. The master source lives in /gd/gnu/lib.
7
8 The GNU C Library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Library General Public License as
10 published by the Free Software Foundation; either version 2 of the
11 License, or (at your option) any later version.
12
13 The GNU C Library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Library General Public License for more details.
17
18 You should have received a copy of the GNU Library General Public
19 License along with the GNU C Library; see the file COPYING.LIB. If not,
20 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 #ifndef _REGEX_H
24 #define _REGEX_H 1
25
26 /* Allow the use in C++ code. */
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30
31 /* POSIX says that <sys/types.h> must be included (by the caller) before
32 <regex.h>. */
33
34 #if !defined _POSIX_C_SOURCE && !defined _POSIX_SOURCE && defined VMS
35 /* VMS doesn't have `size_t' in <sys/types.h>, even though POSIX says it
36 should be there. */
37 # include <stddef.h>
38 #endif
39
40 /* The following two types have to be signed and unsigned integer type
41 wide enough to hold a value of a pointer. For most ANSI compilers
42 ptrdiff_t and size_t should be likely OK. Still size of these two
43 types is 2 for Microsoft C. Ugh... */
44 typedef long int s_reg_t;
45 typedef unsigned long int active_reg_t;
46
47 /* The following bits are used to determine the regexp syntax we
48 recognize. The set/not-set meanings are chosen so that Emacs syntax
49 remains the value 0. The bits are given in alphabetical order, and
50 the definitions shifted by one from the previous bit; thus, when we
51 add or remove a bit, only one other definition need change. */
52 typedef unsigned long int reg_syntax_t;
53
54 /* If this bit is not set, then \ inside a bracket expression is literal.
55 If set, then such a \ quotes the following character. */
56 #define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1)
57
58 /* If this bit is not set, then + and ? are operators, and \+ and \? are
59 literals.
60 If set, then \+ and \? are operators and + and ? are literals. */
61 #define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)
62
63 /* If this bit is set, then character classes are supported. They are:
64 [:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:],
65 [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
66 If not set, then character classes are not supported. */
67 #define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1)
68
69 /* If this bit is set, then ^ and $ are always anchors (outside bracket
70 expressions, of course).
71 If this bit is not set, then it depends:
72 ^ is an anchor if it is at the beginning of a regular
73 expression or after an open-group or an alternation operator;
74 $ is an anchor if it is at the end of a regular expression, or
75 before a close-group or an alternation operator.
76
77 This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because
78 POSIX draft 11.2 says that * etc. in leading positions is undefined.
79 We already implemented a previous draft which made those constructs
80 invalid, though, so we haven't changed the code back. */
81 #define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1)
82
83 /* If this bit is set, then special characters are always special
84 regardless of where they are in the pattern.
85 If this bit is not set, then special characters are special only in
86 some contexts; otherwise they are ordinary. Specifically,
87 * + ? and intervals are only special when not after the beginning,
88 open-group, or alternation operator. */
89 #define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)
90
91 /* If this bit is set, then *, +, ?, and { cannot be first in an re or
92 immediately after an alternation or begin-group operator. */
93 #define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1)
94
95 /* If this bit is set, then . matches newline.
96 If not set, then it doesn't. */
97 #define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1)
98
99 /* If this bit is set, then . doesn't match NUL.
100 If not set, then it does. */
101 #define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1)
102
103 /* If this bit is set, nonmatching lists [^...] do not match newline.
104 If not set, they do. */
105 #define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)
106
107 /* If this bit is set, either \{...\} or {...} defines an
108 interval, depending on RE_NO_BK_BRACES.
109 If not set, \{, \}, {, and } are literals. */
110 #define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)
111
112 /* If this bit is set, +, ? and | aren't recognized as operators.
113 If not set, they are. */
114 #define RE_LIMITED_OPS (RE_INTERVALS << 1)
115
116 /* If this bit is set, newline is an alternation operator.
117 If not set, newline is literal. */
118 #define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)
119
120 /* If this bit is set, then `{...}' defines an interval, and \{ and \}
121 are literals.
122 If not set, then `\{...\}' defines an interval. */
123 #define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)
124
125 /* If this bit is set, (...) defines a group, and \( and \) are literals.
126 If not set, \(...\) defines a group, and ( and ) are literals. */
127 #define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1)
128
129 /* If this bit is set, then \<digit> matches <digit>.
130 If not set, then \<digit> is a back-reference. */
131 #define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)
132
133 /* If this bit is set, then | is an alternation operator, and \| is literal.
134 If not set, then \| is an alternation operator, and | is literal. */
135 #define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)
136
137 /* If this bit is set, then an ending range point collating higher
138 than the starting range point, as in [z-a], is invalid.
139 If not set, then when ending range point collates higher than the
140 starting range point, the range is ignored. */
141 #define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1)
142
143 /* If this bit is set, then an unmatched ) is ordinary.
144 If not set, then an unmatched ) is invalid. */
145 #define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1)
146
147 /* If this bit is set, succeed as soon as we match the whole pattern,
148 without further backtracking. */
149 #define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1)
150
151 /* If this bit is set, do not process the GNU regex operators.
152 If not set, then the GNU regex operators are recognized. */
153 #define RE_NO_GNU_OPS (RE_NO_POSIX_BACKTRACKING << 1)
154
155 /* If this bit is set, turn on internal regex debugging.
156 If not set, and debugging was on, turn it off.
157 This only works if regex.c is compiled -DDEBUG.
158 We define this bit always, so that all that's needed to turn on
159 debugging is to recompile regex.c; the calling code can always have
160 this bit set, and it won't affect anything in the normal case. */
161 #define RE_DEBUG (RE_NO_GNU_OPS << 1)
162
163 /* If this bit is set, a syntactically invalid interval is treated as
164 a string of ordinary characters. For example, the ERE 'a{1' is
165 treated as 'a\{1'. */
166 #define RE_INVALID_INTERVAL_ORD (RE_DEBUG << 1)
167
168 /* This global variable defines the particular regexp syntax to use (for
169 some interfaces). When a regexp is compiled, the syntax used is
170 stored in the pattern buffer, so changing this does not affect
171 already-compiled regexps. */
172 extern reg_syntax_t re_syntax_options;
173
174 /* Define combinations of the above bits for the standard possibilities.
175 (The [[[ comments delimit what gets put into the Texinfo file, so
176 don't delete them!) */
177 /* [[[begin syntaxes]]] */
178 #define RE_SYNTAX_EMACS 0
179
180 #define RE_SYNTAX_AWK \
181 (RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL \
182 | RE_NO_BK_PARENS | RE_NO_BK_REFS \
183 | RE_NO_BK_VBAR | RE_NO_EMPTY_RANGES \
184 | RE_DOT_NEWLINE | RE_CONTEXT_INDEP_ANCHORS \
185 | RE_UNMATCHED_RIGHT_PAREN_ORD | RE_NO_GNU_OPS)
186
187 #define RE_SYNTAX_GNU_AWK \
188 ((RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DEBUG) \
189 & ~(RE_DOT_NOT_NULL | RE_INTERVALS | RE_CONTEXT_INDEP_OPS))
190
191 #define RE_SYNTAX_POSIX_AWK \
192 (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS \
193 | RE_INTERVALS | RE_NO_GNU_OPS)
194
195 #define RE_SYNTAX_GREP \
196 (RE_BK_PLUS_QM | RE_CHAR_CLASSES \
197 | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS \
198 | RE_NEWLINE_ALT)
199
200 #define RE_SYNTAX_EGREP \
201 (RE_CHAR_CLASSES | RE_CONTEXT_INDEP_ANCHORS \
202 | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE \
203 | RE_NEWLINE_ALT | RE_NO_BK_PARENS \
204 | RE_NO_BK_VBAR)
205
206 #define RE_SYNTAX_POSIX_EGREP \
207 (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES \
208 | RE_INVALID_INTERVAL_ORD)
209
210 /* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */
211 #define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC
212
213 #define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC
214
215 /* Syntax bits common to both basic and extended POSIX regex syntax. */
216 #define _RE_SYNTAX_POSIX_COMMON \
217 (RE_CHAR_CLASSES | RE_DOT_NEWLINE | RE_DOT_NOT_NULL \
218 | RE_INTERVALS | RE_NO_EMPTY_RANGES)
219
220 #define RE_SYNTAX_POSIX_BASIC \
221 (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM)
222
223 /* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes
224 RE_LIMITED_OPS, i.e., \? \+ \| are not recognized. Actually, this
225 isn't minimal, since other operators, such as \`, aren't disabled. */
226 #define RE_SYNTAX_POSIX_MINIMAL_BASIC \
227 (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS)
228
229 #define RE_SYNTAX_POSIX_EXTENDED \
230 (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \
231 | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES \
232 | RE_NO_BK_PARENS | RE_NO_BK_VBAR \
233 | RE_CONTEXT_INVALID_OPS | RE_UNMATCHED_RIGHT_PAREN_ORD)
234
235 /* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INDEP_OPS is
236 removed and RE_NO_BK_REFS is added. */
237 #define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \
238 (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \
239 | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES \
240 | RE_NO_BK_PARENS | RE_NO_BK_REFS \
241 | RE_NO_BK_VBAR | RE_UNMATCHED_RIGHT_PAREN_ORD)
242 /* [[[end syntaxes]]] */
243
244 /* Maximum number of duplicates an interval can allow. Some systems
245 (erroneously) define this in other header files, but we want our
246 value, so remove any previous define. */
247 #ifdef RE_DUP_MAX
248 # undef RE_DUP_MAX
249 #endif
250 /* If sizeof(int) == 2, then ((1 << 15) - 1) overflows. */
251 #define RE_DUP_MAX (0x7fff)
252
253
254 /* POSIX `cflags' bits (i.e., information for `regcomp'). */
255
256 /* If this bit is set, then use extended regular expression syntax.
257 If not set, then use basic regular expression syntax. */
258 #define REG_EXTENDED 1
259
260 /* If this bit is set, then ignore case when matching.
261 If not set, then case is significant. */
262 #define REG_ICASE (REG_EXTENDED << 1)
263
264 /* If this bit is set, then anchors do not match at newline
265 characters in the string.
266 If not set, then anchors do match at newlines. */
267 #define REG_NEWLINE (REG_ICASE << 1)
268
269 /* If this bit is set, then report only success or fail in regexec.
270 If not set, then returns differ between not matching and errors. */
271 #define REG_NOSUB (REG_NEWLINE << 1)
272
273
274 /* POSIX `eflags' bits (i.e., information for regexec). */
275
276 /* If this bit is set, then the beginning-of-line operator doesn't match
277 the beginning of the string (presumably because it's not the
278 beginning of a line).
279 If not set, then the beginning-of-line operator does match the
280 beginning of the string. */
281 #define REG_NOTBOL 1
282
283 /* Like REG_NOTBOL, except for the end-of-line. */
284 #define REG_NOTEOL (1 << 1)
285
286
287 /* If any error codes are removed, changed, or added, update the
288 `re_error_msg' table in regex.c. */
289 typedef enum
290 {
291 #ifdef _XOPEN_SOURCE
292 REG_ENOSYS = -1, /* This will never happen for this implementation. */
293 #endif
294
295 REG_NOERROR = 0, /* Success. */
296 REG_NOMATCH, /* Didn't find a match (for regexec). */
297
298 /* POSIX regcomp return error codes. (In the order listed in the
299 standard.) */
300 REG_BADPAT, /* Invalid pattern. */
301 REG_ECOLLATE, /* Not implemented. */
302 REG_ECTYPE, /* Invalid character class name. */
303 REG_EESCAPE, /* Trailing backslash. */
304 REG_ESUBREG, /* Invalid back reference. */
305 REG_EBRACK, /* Unmatched left bracket. */
306 REG_EPAREN, /* Parenthesis imbalance. */
307 REG_EBRACE, /* Unmatched \{. */
308 REG_BADBR, /* Invalid contents of \{\}. */
309 REG_ERANGE, /* Invalid range end. */
310 REG_ESPACE, /* Ran out of memory. */
311 REG_BADRPT, /* No preceding re for repetition op. */
312
313 /* Error codes we've added. */
314 REG_EEND, /* Premature end. */
315 REG_ESIZE, /* Compiled pattern bigger than 2^16 bytes. */
316 REG_ERPAREN /* Unmatched ) or \); not returned from regcomp. */
317 } reg_errcode_t;
318
319 /* This data structure represents a compiled pattern. Before calling
320 the pattern compiler, the fields `buffer', `allocated', `fastmap',
321 `translate', and `no_sub' can be set. After the pattern has been
322 compiled, the `re_nsub' field is available. All other fields are
323 private to the regex routines. */
324
325 #ifndef RE_TRANSLATE_TYPE
326 # define RE_TRANSLATE_TYPE char *
327 #endif
328
329 struct re_pattern_buffer
330 {
331 /* [[[begin pattern_buffer]]] */
332 /* Space that holds the compiled pattern. It is declared as
333 `unsigned char *' because its elements are
334 sometimes used as array indexes. */
335 unsigned char *buffer;
336
337 /* Number of bytes to which `buffer' points. */
338 unsigned long int allocated;
339
340 /* Number of bytes actually used in `buffer'. */
341 unsigned long int used;
342
343 /* Syntax setting with which the pattern was compiled. */
344 reg_syntax_t syntax;
345
346 /* Pointer to a fastmap, if any, otherwise zero. re_search uses
347 the fastmap, if there is one, to skip over impossible
348 starting points for matches. */
349 char *fastmap;
350
351 /* Either a translate table to apply to all characters before
352 comparing them, or zero for no translation. The translation
353 is applied to a pattern when it is compiled and to a string
354 when it is matched. */
355 RE_TRANSLATE_TYPE translate;
356
357 /* Number of subexpressions found by the compiler. */
358 size_t re_nsub;
359
360 /* Zero if this pattern cannot match the empty string, one else.
361 Well, in truth it's used only in `re_search_2', to see
362 whether or not we should use the fastmap, so we don't set
363 this absolutely perfectly; see `re_compile_fastmap' (the
364 `duplicate' case). */
365 unsigned can_be_null : 1;
366
367 /* If REGS_UNALLOCATED, allocate space in the `regs' structure
368 for `max (RE_NREGS, re_nsub + 1)' groups.
369 If REGS_REALLOCATE, reallocate space if necessary.
370 If REGS_FIXED, use what's there. */
371 #define REGS_UNALLOCATED 0
372 #define REGS_REALLOCATE 1
373 #define REGS_FIXED 2
374 unsigned regs_allocated : 2;
375
376 /* Set to zero when `regex_compile' compiles a pattern; set to one
377 by `re_compile_fastmap' if it updates the fastmap. */
378 unsigned fastmap_accurate : 1;
379
380 /* If set, `re_match_2' does not return information about
381 subexpressions. */
382 unsigned no_sub : 1;
383
384 /* If set, a beginning-of-line anchor doesn't match at the
385 beginning of the string. */
386 unsigned not_bol : 1;
387
388 /* Similarly for an end-of-line anchor. */
389 unsigned not_eol : 1;
390
391 /* If true, an anchor at a newline matches. */
392 unsigned newline_anchor : 1;
393
394 /* [[[end pattern_buffer]]] */
395 };
396
397 typedef struct re_pattern_buffer regex_t;
398
399 /* Type for byte offsets within the string. POSIX mandates this. */
400 typedef int regoff_t;
401
402
403 /* This is the structure we store register match data in. See
404 regex.texinfo for a full description of what registers match. */
405 struct re_registers
406 {
407 unsigned num_regs;
408 regoff_t *start;
409 regoff_t *end;
410 };
411
412
413 /* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
414 `re_match_2' returns information about at least this many registers
415 the first time a `regs' structure is passed. */
416 #ifndef RE_NREGS
417 # define RE_NREGS 30
418 #endif
419
420
421 /* POSIX specification for registers. Aside from the different names than
422 `re_registers', POSIX uses an array of structures, instead of a
423 structure of arrays. */
424 typedef struct
425 {
426 regoff_t rm_so; /* Byte offset from string's start to substring's start. */
427 regoff_t rm_eo; /* Byte offset from string's start to substring's end. */
428 } regmatch_t;
429
430 /* Declarations for routines. */
431
432 /* To avoid duplicating every routine declaration -- once with a
433 prototype (if we are ANSI), and once without (if we aren't) -- we
434 use the following macro to declare argument types. This
435 unfortunately clutters up the declarations a bit, but I think it's
436 worth it. */
437
438 #if __STDC__
439
440 # define _RE_ARGS(args) args
441
442 #else /* not __STDC__ */
443
444 # define _RE_ARGS(args) ()
445
446 #endif /* not __STDC__ */
447
448 /* Sets the current default syntax to SYNTAX, and return the old syntax.
449 You can also simply assign to the `re_syntax_options' variable. */
450 extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax));
451
452 /* Compile the regular expression PATTERN, with length LENGTH
453 and syntax given by the global `re_syntax_options', into the buffer
454 BUFFER. Return NULL if successful, and an error string if not. */
455 extern const char *re_compile_pattern
456 _RE_ARGS ((const char *pattern, size_t length,
457 struct re_pattern_buffer *buffer));
458
459
460 /* Compile a fastmap for the compiled pattern in BUFFER; used to
461 accelerate searches. Return 0 if successful and -2 if was an
462 internal error. */
463 extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
464
465
466 /* Search in the string STRING (with length LENGTH) for the pattern
467 compiled into BUFFER. Start searching at position START, for RANGE
468 characters. Return the starting position of the match, -1 for no
469 match, or -2 for an internal error. Also return register
470 information in REGS (if REGS and BUFFER->no_sub are nonzero). */
471 extern int re_search
472 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
473 int length, int start, int range, struct re_registers *regs));
474
475
476 /* Like `re_search', but search in the concatenation of STRING1 and
477 STRING2. Also, stop searching at index START + STOP. */
478 extern int re_search_2
479 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
480 int length1, const char *string2, int length2,
481 int start, int range, struct re_registers *regs, int stop));
482
483
484 /* Like `re_search', but return how many characters in STRING the regexp
485 in BUFFER matched, starting at position START. */
486 extern int re_match
487 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
488 int length, int start, struct re_registers *regs));
489
490
491 /* Relates to `re_match' as `re_search_2' relates to `re_search'. */
492 extern int re_match_2
493 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
494 int length1, const char *string2, int length2,
495 int start, struct re_registers *regs, int stop));
496
497
498 /* Set REGS to hold NUM_REGS registers, storing them in STARTS and
499 ENDS. Subsequent matches using BUFFER and REGS will use this memory
500 for recording register information. STARTS and ENDS must be
501 allocated with malloc, and must each be at least `NUM_REGS * sizeof
502 (regoff_t)' bytes long.
503
504 If NUM_REGS == 0, then subsequent matches should allocate their own
505 register data.
506
507 Unless this function is called, the first search or match using
508 PATTERN_BUFFER will allocate its own register data, without
509 freeing the old data. */
510 extern void re_set_registers
511 _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,
512 unsigned num_regs, regoff_t *starts, regoff_t *ends));
513
514 #if defined _REGEX_RE_COMP || defined _LIBC
515 # ifndef _CRAY
516 /* 4.2 bsd compatibility. */
517 extern char *re_comp _RE_ARGS ((const char *));
518 extern int re_exec _RE_ARGS ((const char *));
519 # endif
520 #endif
521
522 /* GCC 2.95 and later have "__restrict"; C99 compilers have
523 "restrict", and "configure" may have defined "restrict". */
524 #ifndef __restrict
525 # if ! (2 < __GNUC__ || (2 == __GNUC__ && 95 <= __GNUC_MINOR__))
526 # if defined restrict || 199901L <= __STDC_VERSION__
527 # define __restrict restrict
528 # else
529 # define __restrict
530 # endif
531 # endif
532 #endif
533
534 #ifndef __restrict_arr
535 # define __restrict_arr
536 #endif
537
538 /* POSIX compatibility. */
539 extern int regcomp _RE_ARGS ((regex_t *__restrict __preg,
540 const char *__restrict __pattern,
541 int __cflags));
542
543 extern int regexec _RE_ARGS ((const regex_t *__restrict __preg,
544 const char *__restrict __string, size_t __nmatch,
545 regmatch_t __pmatch[__restrict_arr],
546 int __eflags));
547
548 extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
549 char *__errbuf, size_t __errbuf_size));
550
551 extern void regfree _RE_ARGS ((regex_t *__preg));
552
553
554 #ifdef __cplusplus
555 }
556 #endif /* C++ */
557
558 #endif /* regex.h */
559
560 /*
561 Local variables:
562 make-backup-files: t
563 version-control: t
564 trim-versions-without-asking: nil
565 End:
566 */
1 #ifndef _REGEX_H
2 #include <posix/regex.h>
3
4 /* Document internal interfaces. */
5 extern reg_syntax_t __re_set_syntax _RE_ARGS ((reg_syntax_t syntax));
6
7 extern const char *__re_compile_pattern
8 _RE_ARGS ((const char *pattern, size_t length,
9 struct re_pattern_buffer *buffer));
10
11 extern int __re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
12
13 extern int __re_search
14 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
15 int length, int start, int range, struct re_registers *regs));
16
17 extern int __re_search_2
18 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
19 int length1, const char *string2, int length2,
20 int start, int range, struct re_registers *regs, int stop));
21
22 extern int __re_match
23 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
24 int length, int start, struct re_registers *regs));
25
26 extern int __re_match_2
27 _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
28 int length1, const char *string2, int length2,
29 int start, struct re_registers *regs, int stop));
30
31 extern void __re_set_registers
32 _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,
33 unsigned num_regs, regoff_t *starts, regoff_t *ends));
34
35 extern int __regcomp _RE_ARGS ((regex_t *__preg, const char *__pattern,
36 int __cflags));
37
38 extern int __regexec _RE_ARGS ((const regex_t *__preg,
39 const char *__string, size_t __nmatch,
40 regmatch_t __pmatch[], int __eflags));
41
42 extern size_t __regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
43 char *__errbuf, size_t __errbuf_size));
44
45 extern void __regfree _RE_ARGS ((regex_t *__preg));
46 #endif