Skip to content

John McEleney / mailutils

Go to a project
Toggle navigation
Toggle navigation pinning
Commit 9de013a2 9de013a2b0571e5e748237e40fd849e2692d4e79 by Sergey Poznyakoff
Options

Removed

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