regex.h@ 3611

Last change on this file since 3611 was 3611, checked in by bird, 7 months ago
vendor/sed/current: GNU sed 4.9 (sed-4.9.tar.xz sha256:6e226b732e1cd739464ad6862bd1a1aba42d7982922da7a53519631d24975181)
File size: 25.3 KB

Line
1	/* Definitions for data structures and routines for the regular
2	expression library.
3	Copyright (C) 1985, 1989-2022 Free Software Foundation, Inc.
4	This file is part of the GNU C Library.
5
6	The GNU C Library is free software; you can redistribute it and/or
7	modify it under the terms of the GNU Lesser General Public
8	License as published by the Free Software Foundation; either
9	version 2.1 of the License, or (at your option) any later version.
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	Lesser General Public License for more details.
15
16	You should have received a copy of the GNU Lesser General Public
17	License along with the GNU C Library; if not, see
18	<https://www.gnu.org/licenses/>. */
19
20	#ifndef _REGEX_H
21	#define _REGEX_H 1
22
23	#include <sys/types.h>
24
25	/* Allow the use in C++ code. */
26	#ifdef __cplusplus
27	extern "C" {
28	#endif
29
30	/* Define __USE_GNU to declare GNU extensions that violate the
31	POSIX name space rules. */
32	#ifdef _GNU_SOURCE
33	# define __USE_GNU 1
34	#endif
35
36	#ifdef _REGEX_LARGE_OFFSETS
37
38	/* Use types and values that are wide enough to represent signed and
39	unsigned byte offsets in memory. This currently works only when
40	the regex code is used outside of the GNU C library; it is not yet
41	supported within glibc itself, and glibc users should not define
42	_REGEX_LARGE_OFFSETS. */
43
44	/* The type of object sizes. */
45	typedef size_t __re_size_t;
46
47	/* The type of object sizes, in places where the traditional code
48	uses unsigned long int. */
49	typedef size_t __re_long_size_t;
50
51	#else
52
53	/* The traditional GNU regex implementation mishandles strings longer
54	than INT_MAX. */
55	typedef unsigned int __re_size_t;
56	typedef unsigned long int __re_long_size_t;
57
58	#endif
59
60	/* The following two types have to be signed and unsigned integer type
61	wide enough to hold a value of a pointer. For most ANSI compilers
62	ptrdiff_t and size_t should be likely OK. Still size of these two
63	types is 2 for Microsoft C. Ugh... */
64	typedef long int s_reg_t;
65	typedef unsigned long int active_reg_t;
66
67	/* The following bits are used to determine the regexp syntax we
68	recognize. The set/not-set meanings are chosen so that Emacs syntax
69	remains the value 0. The bits are given in alphabetical order, and
70	the definitions shifted by one from the previous bit; thus, when we
71	add or remove a bit, only one other definition need change. */
72	typedef unsigned long int reg_syntax_t;
73
74	#ifdef __USE_GNU
75	/* If this bit is not set, then \ inside a bracket expression is literal.
76	If set, then such a \ quotes the following character. */
77	# define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1)
78
79	/* If this bit is not set, then + and ? are operators, and \+ and \? are
80	literals.
81	If set, then \+ and \? are operators and + and ? are literals. */
82	# define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)
83
84	/* If this bit is set, then character classes are supported. They are:
85	[:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:],
86	[:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
87	If not set, then character classes are not supported. */
88	# define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1)
89
90	/* If this bit is set, then ^ and $ are always anchors (outside bracket
91	expressions, of course).
92	If this bit is not set, then it depends:
93	^ is an anchor if it is at the beginning of a regular
94	expression or after an open-group or an alternation operator;
95	$ is an anchor if it is at the end of a regular expression, or
96	before a close-group or an alternation operator.
97
98	This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because
99	POSIX draft 11.2 says that * etc. in leading positions is undefined.
100	We already implemented a previous draft which made those constructs
101	invalid, though, so we haven't changed the code back. */
102	# define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1)
103
104	/* If this bit is set, then special characters are always special
105	regardless of where they are in the pattern.
106	If this bit is not set, then special characters are special only in
107	some contexts; otherwise they are ordinary. Specifically,
108	* + ? and intervals are only special when not after the beginning,
109	open-group, or alternation operator. */
110	# define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)
111
112	/* If this bit is set, then *, +, ?, and { cannot be first in an re or
113	immediately after an alternation or begin-group operator. */
114	# define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1)
115
116	/* If this bit is set, then . matches newline.
117	If not set, then it doesn't. */
118	# define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1)
119
120	/* If this bit is set, then . doesn't match NUL.
121	If not set, then it does. */
122	# define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1)
123
124	/* If this bit is set, nonmatching lists [^...] do not match newline.
125	If not set, they do. */
126	# define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)
127
128	/* If this bit is set, either \{...\} or {...} defines an
129	interval, depending on RE_NO_BK_BRACES.
130	If not set, \{, \}, {, and } are literals. */
131	# define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)
132
133	/* If this bit is set, +, ? and \| aren't recognized as operators.
134	If not set, they are. */
135	# define RE_LIMITED_OPS (RE_INTERVALS << 1)
136
137	/* If this bit is set, newline is an alternation operator.
138	If not set, newline is literal. */
139	# define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)
140
141	/* If this bit is set, then '{...}' defines an interval, and \{ and \}
142	are literals.
143	If not set, then '\{...\}' defines an interval. */
144	# define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)
145
146	/* If this bit is set, (...) defines a group, and $ and $ are literals.
147	If not set, $...$ defines a group, and ( and ) are literals. */
148	# define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1)
149
150	/* If this bit is set, then \<digit> matches <digit>.
151	If not set, then \<digit> is a back-reference. */
152	# define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)
153
154	/* If this bit is set, then \| is an alternation operator, and \\| is literal.
155	If not set, then \\| is an alternation operator, and \| is literal. */
156	# define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)
157
158	/* If this bit is set, then an ending range point collating higher
159	than the starting range point, as in [z-a], is invalid.
160	If not set, then when ending range point collates higher than the
161	starting range point, the range is ignored. */
162	# define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1)
163
164	/* If this bit is set, then an unmatched ) is ordinary.
165	If not set, then an unmatched ) is invalid. */
166	# define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1)
167
168	/* If this bit is set, succeed as soon as we match the whole pattern,
169	without further backtracking. */
170	# define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1)
171
172	/* If this bit is set, do not process the GNU regex operators.
173	If not set, then the GNU regex operators are recognized. */
174	# define RE_NO_GNU_OPS (RE_NO_POSIX_BACKTRACKING << 1)
175
176	/* If this bit is set, turn on internal regex debugging.
177	If not set, and debugging was on, turn it off.
178	This only works if regex.c is compiled -DDEBUG.
179	We define this bit always, so that all that's needed to turn on
180	debugging is to recompile regex.c; the calling code can always have
181	this bit set, and it won't affect anything in the normal case. */
182	# define RE_DEBUG (RE_NO_GNU_OPS << 1)
183
184	/* If this bit is set, a syntactically invalid interval is treated as
185	a string of ordinary characters. For example, the ERE 'a{1' is
186	treated as 'a\{1'. */
187	# define RE_INVALID_INTERVAL_ORD (RE_DEBUG << 1)
188
189	/* If this bit is set, then ignore case when matching.
190	If not set, then case is significant. */
191	# define RE_ICASE (RE_INVALID_INTERVAL_ORD << 1)
192
193	/* This bit is used internally like RE_CONTEXT_INDEP_ANCHORS but only
194	for ^, because it is difficult to scan the regex backwards to find
195	whether ^ should be special. */
196	# define RE_CARET_ANCHORS_HERE (RE_ICASE << 1)
197
198	/* If this bit is set, then \{ cannot be first in a regex or
199	immediately after an alternation, open-group or \} operator. */
200	# define RE_CONTEXT_INVALID_DUP (RE_CARET_ANCHORS_HERE << 1)
201
202	/* If this bit is set, then no_sub will be set to 1 during
203	re_compile_pattern. */
204	# define RE_NO_SUB (RE_CONTEXT_INVALID_DUP << 1)
205	#endif
206
207	/* This global variable defines the particular regexp syntax to use (for
208	some interfaces). When a regexp is compiled, the syntax used is
209	stored in the pattern buffer, so changing this does not affect
210	already-compiled regexps. */
211	extern reg_syntax_t re_syntax_options;
212
213
214	#ifdef __USE_GNU
215	/* Define combinations of the above bits for the standard possibilities.
216	(The [[[ comments delimit what gets put into the Texinfo file, so
217	don't delete them!) */
218	/* [[[begin syntaxes]]] */
219	# define RE_SYNTAX_EMACS 0
220
221	# define RE_SYNTAX_AWK \
222	(RE_BACKSLASH_ESCAPE_IN_LISTS \| RE_DOT_NOT_NULL \
223	\| RE_NO_BK_PARENS \| RE_NO_BK_REFS \
224	\| RE_NO_BK_VBAR \| RE_NO_EMPTY_RANGES \
225	\| RE_DOT_NEWLINE \| RE_CONTEXT_INDEP_ANCHORS \
226	\| RE_CHAR_CLASSES \
227	\| RE_UNMATCHED_RIGHT_PAREN_ORD \| RE_NO_GNU_OPS)
228
229	# define RE_SYNTAX_GNU_AWK \
230	((RE_SYNTAX_POSIX_EXTENDED \| RE_BACKSLASH_ESCAPE_IN_LISTS \
231	\| RE_INVALID_INTERVAL_ORD) \
232	& ~(RE_DOT_NOT_NULL \| RE_CONTEXT_INDEP_OPS \
233	\| RE_CONTEXT_INVALID_OPS ))
234
235	# define RE_SYNTAX_POSIX_AWK \
236	(RE_SYNTAX_POSIX_EXTENDED \| RE_BACKSLASH_ESCAPE_IN_LISTS \
237	\| RE_INTERVALS \| RE_NO_GNU_OPS \
238	\| RE_INVALID_INTERVAL_ORD)
239
240	# define RE_SYNTAX_GREP \
241	((RE_SYNTAX_POSIX_BASIC \| RE_NEWLINE_ALT) \
242	& ~(RE_CONTEXT_INVALID_DUP \| RE_DOT_NOT_NULL))
243
244	# define RE_SYNTAX_EGREP \
245	((RE_SYNTAX_POSIX_EXTENDED \| RE_INVALID_INTERVAL_ORD \| RE_NEWLINE_ALT) \
246	& ~(RE_CONTEXT_INVALID_OPS \| RE_DOT_NOT_NULL))
247
248	/* POSIX grep -E behavior is no longer incompatible with GNU. */
249	# define RE_SYNTAX_POSIX_EGREP \
250	RE_SYNTAX_EGREP
251
252	/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */
253	# define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC
254
255	# define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC
256
257	/* Syntax bits common to both basic and extended POSIX regex syntax. */
258	# define _RE_SYNTAX_POSIX_COMMON \
259	(RE_CHAR_CLASSES \| RE_DOT_NEWLINE \| RE_DOT_NOT_NULL \
260	\| RE_INTERVALS \| RE_NO_EMPTY_RANGES)
261
262	# define RE_SYNTAX_POSIX_BASIC \
263	(_RE_SYNTAX_POSIX_COMMON \| RE_BK_PLUS_QM \| RE_CONTEXT_INVALID_DUP)
264
265	/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes
266	RE_LIMITED_OPS, i.e., \? \+ \\| are not recognized. Actually, this
267	isn't minimal, since other operators, such as \`, aren't disabled. */
268	# define RE_SYNTAX_POSIX_MINIMAL_BASIC \
269	(_RE_SYNTAX_POSIX_COMMON \| RE_LIMITED_OPS)
270
271	# define RE_SYNTAX_POSIX_EXTENDED \
272	(_RE_SYNTAX_POSIX_COMMON \| RE_CONTEXT_INDEP_ANCHORS \
273	\| RE_CONTEXT_INDEP_OPS \| RE_NO_BK_BRACES \
274	\| RE_NO_BK_PARENS \| RE_NO_BK_VBAR \
275	\| RE_CONTEXT_INVALID_OPS \| RE_UNMATCHED_RIGHT_PAREN_ORD)
276
277	/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INDEP_OPS is
278	removed and RE_NO_BK_REFS is added. */
279	# define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \
280	(_RE_SYNTAX_POSIX_COMMON \| RE_CONTEXT_INDEP_ANCHORS \
281	\| RE_CONTEXT_INVALID_OPS \| RE_NO_BK_BRACES \
282	\| RE_NO_BK_PARENS \| RE_NO_BK_REFS \
283	\| RE_NO_BK_VBAR \| RE_UNMATCHED_RIGHT_PAREN_ORD)
284	/* [[[end syntaxes]]] */
285
286	/* Maximum number of duplicates an interval can allow. POSIX-conforming
287	systems might define this in <limits.h>, but we want our
288	value, so remove any previous define. */
289	# ifdef _REGEX_INCLUDE_LIMITS_H
290	# include <limits.h>
291	# endif
292	# ifdef RE_DUP_MAX
293	# undef RE_DUP_MAX
294	# endif
295
296	/* RE_DUP_MAX is 2**15 - 1 because an earlier implementation stored
297	the counter as a 2-byte signed integer. This is no longer true, so
298	RE_DUP_MAX could be increased to (INT_MAX / 10 - 1), or to
299	((SIZE_MAX - 9) / 10) if _REGEX_LARGE_OFFSETS is defined.
300	However, there would be a huge performance problem if someone
301	actually used a pattern like a\{214748363\}, so RE_DUP_MAX retains
302	its historical value. */
303	# define RE_DUP_MAX (0x7fff)
304	#endif
305
306
307	/* POSIX 'cflags' bits (i.e., information for 'regcomp'). */
308
309	/* If this bit is set, then use extended regular expression syntax.
310	If not set, then use basic regular expression syntax. */
311	#define REG_EXTENDED 1
312
313	/* If this bit is set, then ignore case when matching.
314	If not set, then case is significant. */
315	#define REG_ICASE (1 << 1)
316
317	/* If this bit is set, then anchors do not match at newline
318	characters in the string.
319	If not set, then anchors do match at newlines. */
320	#define REG_NEWLINE (1 << 2)
321
322	/* If this bit is set, then report only success or fail in regexec.
323	If not set, then returns differ between not matching and errors. */
324	#define REG_NOSUB (1 << 3)
325
326
327	/* POSIX 'eflags' bits (i.e., information for regexec). */
328
329	/* If this bit is set, then the beginning-of-line operator doesn't match
330	the beginning of the string (presumably because it's not the
331	beginning of a line).
332	If not set, then the beginning-of-line operator does match the
333	beginning of the string. */
334	#define REG_NOTBOL 1
335
336	/* Like REG_NOTBOL, except for the end-of-line. */
337	#define REG_NOTEOL (1 << 1)
338
339	/* Use PMATCH[0] to delimit the start and end of the search in the
340	buffer. */
341	#define REG_STARTEND (1 << 2)
342
343
344	/* If any error codes are removed, changed, or added, update the
345	'__re_error_msgid' table in regcomp.c. */
346
347	typedef enum
348	{
349	_REG_ENOSYS = -1, /* This will never happen for this implementation. */
350	_REG_NOERROR = 0, /* Success. */
351	_REG_NOMATCH, /* Didn't find a match (for regexec). */
352
353	/* POSIX regcomp return error codes. (In the order listed in the
354	standard.) */
355	_REG_BADPAT, /* Invalid pattern. */
356	_REG_ECOLLATE, /* Invalid collating element. */
357	_REG_ECTYPE, /* Invalid character class name. */
358	_REG_EESCAPE, /* Trailing backslash. */
359	_REG_ESUBREG, /* Invalid back reference. */
360	_REG_EBRACK, /* Unmatched left bracket. */
361	_REG_EPAREN, /* Parenthesis imbalance. */
362	_REG_EBRACE, /* Unmatched \{. */
363	_REG_BADBR, /* Invalid contents of \{\}. */
364	_REG_ERANGE, /* Invalid range end. */
365	_REG_ESPACE, /* Ran out of memory. */
366	_REG_BADRPT, /* No preceding re for repetition op. */
367
368	/* Error codes we've added. */
369	_REG_EEND, /* Premature end. */
370	_REG_ESIZE, /* Too large (e.g., repeat count too large). */
371	_REG_ERPAREN /* Unmatched ) or \); not returned from regcomp. */
372	} reg_errcode_t;
373
374	#if defined _XOPEN_SOURCE \|\| defined __USE_XOPEN2K
375	# define REG_ENOSYS _REG_ENOSYS
376	#endif
377	#define REG_NOERROR _REG_NOERROR
378	#define REG_NOMATCH _REG_NOMATCH
379	#define REG_BADPAT _REG_BADPAT
380	#define REG_ECOLLATE _REG_ECOLLATE
381	#define REG_ECTYPE _REG_ECTYPE
382	#define REG_EESCAPE _REG_EESCAPE
383	#define REG_ESUBREG _REG_ESUBREG
384	#define REG_EBRACK _REG_EBRACK
385	#define REG_EPAREN _REG_EPAREN
386	#define REG_EBRACE _REG_EBRACE
387	#define REG_BADBR _REG_BADBR
388	#define REG_ERANGE _REG_ERANGE
389	#define REG_ESPACE _REG_ESPACE
390	#define REG_BADRPT _REG_BADRPT
391	#define REG_EEND _REG_EEND
392	#define REG_ESIZE _REG_ESIZE
393	#define REG_ERPAREN _REG_ERPAREN
394
395
396	/* This data structure represents a compiled pattern. Before calling
397	the pattern compiler, the fields 'buffer', 'allocated', 'fastmap',
398	and 'translate' can be set. After the pattern has been compiled,
399	the fields 're_nsub', 'not_bol' and 'not_eol' are available. All
400	other fields are private to the regex routines. */
401
402	#ifndef RE_TRANSLATE_TYPE
403	# define __RE_TRANSLATE_TYPE unsigned char *
404	# ifdef __USE_GNU
405	# define RE_TRANSLATE_TYPE __RE_TRANSLATE_TYPE
406	# endif
407	#endif
408
409	#ifdef __USE_GNU
410	# define __REPB_PREFIX(name) name
411	#else
412	# define __REPB_PREFIX(name) __##name
413	#endif
414
415	struct re_pattern_buffer
416	{
417	/* Space that holds the compiled pattern. The type
418	'struct re_dfa_t' is private and is not declared here. */
419	struct re_dfa_t *__REPB_PREFIX(buffer);
420
421	/* Number of bytes to which 'buffer' points. */
422	__re_long_size_t __REPB_PREFIX(allocated);
423
424	/* Number of bytes actually used in 'buffer'. */
425	__re_long_size_t __REPB_PREFIX(used);
426
427	/* Syntax setting with which the pattern was compiled. */
428	reg_syntax_t __REPB_PREFIX(syntax);
429
430	/* Pointer to a fastmap, if any, otherwise zero. re_search uses the
431	fastmap, if there is one, to skip over impossible starting points
432	for matches. */
433	char *__REPB_PREFIX(fastmap);
434
435	/* Either a translate table to apply to all characters before
436	comparing them, or zero for no translation. The translation is
437	applied to a pattern when it is compiled and to a string when it
438	is matched. */
439	__RE_TRANSLATE_TYPE __REPB_PREFIX(translate);
440
441	/* Number of subexpressions found by the compiler. */
442	size_t re_nsub;
443
444	/* Zero if this pattern cannot match the empty string, one else.
445	Well, in truth it's used only in 're_search_2', to see whether or
446	not we should use the fastmap, so we don't set this absolutely
447	perfectly; see 're_compile_fastmap' (the "duplicate" case). */
448	unsigned __REPB_PREFIX(can_be_null) : 1;
449
450	/* If REGS_UNALLOCATED, allocate space in the 'regs' structure
451	for 'max (RE_NREGS, re_nsub + 1)' groups.
452	If REGS_REALLOCATE, reallocate space if necessary.
453	If REGS_FIXED, use what's there. */
454	#ifdef __USE_GNU
455	# define REGS_UNALLOCATED 0
456	# define REGS_REALLOCATE 1
457	# define REGS_FIXED 2
458	#endif
459	unsigned __REPB_PREFIX(regs_allocated) : 2;
460
461	/* Set to zero when 're_compile_pattern' compiles a pattern; set to
462	one by 're_compile_fastmap' if it updates the fastmap. */
463	unsigned __REPB_PREFIX(fastmap_accurate) : 1;
464
465	/* If set, 're_match_2' does not return information about
466	subexpressions. */
467	unsigned __REPB_PREFIX(no_sub) : 1;
468
469	/* If set, a beginning-of-line anchor doesn't match at the beginning
470	of the string. */
471	unsigned __REPB_PREFIX(not_bol) : 1;
472
473	/* Similarly for an end-of-line anchor. */
474	unsigned __REPB_PREFIX(not_eol) : 1;
475
476	/* If true, an anchor at a newline matches. */
477	unsigned __REPB_PREFIX(newline_anchor) : 1;
478	};
479
480	typedef struct re_pattern_buffer regex_t;
481
482
483	/* Type for byte offsets within the string. POSIX mandates this. */
484	#ifdef _REGEX_LARGE_OFFSETS
485	/* POSIX 1003.1-2008 requires that regoff_t be at least as wide as
486	ptrdiff_t and ssize_t. We don't know of any hosts where ptrdiff_t
487	is wider than ssize_t, so ssize_t is safe. ptrdiff_t is not
488	visible here, so use ssize_t. */
489	typedef ssize_t regoff_t;
490	#else
491	/* The traditional GNU regex implementation mishandles strings longer
492	than INT_MAX. */
493	typedef int regoff_t;
494	#endif
495
496
497	#ifdef __USE_GNU
498	/* This is the structure we store register match data in. See
499	regex.texinfo for a full description of what registers match. */
500	struct re_registers
501	{
502	__re_size_t num_regs;
503	regoff_t *start;
504	regoff_t *end;
505	};
506
507
508	/* If 'regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
509	're_match_2' returns information about at least this many registers
510	the first time a 'regs' structure is passed. */
511	# ifndef RE_NREGS
512	# define RE_NREGS 30
513	# endif
514	#endif
515
516
517	/* POSIX specification for registers. Aside from the different names than
518	're_registers', POSIX uses an array of structures, instead of a
519	structure of arrays. */
520	typedef struct
521	{
522	regoff_t rm_so; /* Byte offset from string's start to substring's start. */
523	regoff_t rm_eo; /* Byte offset from string's start to substring's end. */
524	} regmatch_t;
525
526
527	/* Declarations for routines. */
528
529	#ifndef _REGEX_NELTS
530	# if (defined __STDC_VERSION__ && 199901L <= __STDC_VERSION__ \
531	&& !defined __STDC_NO_VLA__)
532	# define _REGEX_NELTS(n) n
533	# else
534	# define _REGEX_NELTS(n)
535	# endif
536	#endif
537
538	#if defined __GNUC__ && 4 < __GNUC__ + (6 <= __GNUC_MINOR__)
539	# pragma GCC diagnostic push
540	# pragma GCC diagnostic ignored "-Wvla"
541	#endif
542
543	#ifndef _Attr_access_
544	# ifdef __attr_access
545	# define _Attr_access_(arg) __attr_access (arg)
546	# elif defined __GNUC__ && 10 <= __GNUC__
547	# define _Attr_access_(x) __attribute__ ((__access__ x))
548	# else
549	# define _Attr_access_(x)
550	# endif
551	#endif
552
553	#ifdef __USE_GNU
554	/* Sets the current default syntax to SYNTAX, and return the old syntax.
555	You can also simply assign to the 're_syntax_options' variable. */
556	extern reg_syntax_t re_set_syntax (reg_syntax_t __syntax);
557
558	/* Compile the regular expression PATTERN, with length LENGTH
559	and syntax given by the global 're_syntax_options', into the buffer
560	BUFFER. Return NULL if successful, and an error string if not.
561
562	To free the allocated storage, you must call 'regfree' on BUFFER.
563	Note that the translate table must either have been initialized by
564	'regcomp', with a malloc'ed value, or set to NULL before calling
565	'regfree'. */
566	extern const char re_compile_pattern (const char __pattern, size_t __length,
567	struct re_pattern_buffer *__buffer)
568	_Attr_access_ ((__read_only__, 1, 2));
569
570
571	/* Compile a fastmap for the compiled pattern in BUFFER; used to
572	accelerate searches. Return 0 if successful and -2 if was an
573	internal error. */
574	extern int re_compile_fastmap (struct re_pattern_buffer *__buffer);
575
576
577	/* Search in the string STRING (with length LENGTH) for the pattern
578	compiled into BUFFER. Start searching at position START, for RANGE
579	characters. Return the starting position of the match, -1 for no
580	match, or -2 for an internal error. Also return register
581	information in REGS (if REGS and BUFFER->no_sub are nonzero). */
582	extern regoff_t re_search (struct re_pattern_buffer *__buffer,
583	const char *__String, regoff_t __length,
584	regoff_t __start, regoff_t __range,
585	struct re_registers *__regs)
586	_Attr_access_ ((__read_only__, 2, 3));
587
588
589	/* Like 're_search', but search in the concatenation of STRING1 and
590	STRING2. Also, stop searching at index START + STOP. */
591	extern regoff_t re_search_2 (struct re_pattern_buffer *__buffer,
592	const char *__string1, regoff_t __length1,
593	const char *__string2, regoff_t __length2,
594	regoff_t __start, regoff_t __range,
595	struct re_registers *__regs,
596	regoff_t __stop)
597	_Attr_access_ ((__read_only__, 2, 3))
598	_Attr_access_ ((__read_only__, 4, 5));
599
600
601	/* Like 're_search', but return how many characters in STRING the regexp
602	in BUFFER matched, starting at position START. */
603	extern regoff_t re_match (struct re_pattern_buffer *__buffer,
604	const char *__String, regoff_t __length,
605	regoff_t __start, struct re_registers *__regs)
606	_Attr_access_ ((__read_only__, 2, 3));
607
608
609	/* Relates to 're_match' as 're_search_2' relates to 're_search'. */
610	extern regoff_t re_match_2 (struct re_pattern_buffer *__buffer,
611	const char *__string1, regoff_t __length1,
612	const char *__string2, regoff_t __length2,
613	regoff_t __start, struct re_registers *__regs,
614	regoff_t __stop)
615	_Attr_access_ ((__read_only__, 2, 3))
616	_Attr_access_ ((__read_only__, 4, 5));
617
618
619	/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
620	ENDS. Subsequent matches using BUFFER and REGS will use this memory
621	for recording register information. STARTS and ENDS must be
622	allocated with malloc, and must each be at least 'NUM_REGS * sizeof
623	(regoff_t)' bytes long.
624
625	If NUM_REGS == 0, then subsequent matches should allocate their own
626	register data.
627
628	Unless this function is called, the first search or match using
629	BUFFER will allocate its own register data, without
630	freeing the old data. */
631	extern void re_set_registers (struct re_pattern_buffer *__buffer,
632	struct re_registers *__regs,
633	__re_size_t __num_regs,
634	regoff_t __starts, regoff_t __ends);
635	#endif /* Use GNU */
636
637	#if defined _REGEX_RE_COMP \|\| (defined _LIBC && defined __USE_MISC)
638	/* 4.2 bsd compatibility. */
639	extern char re_comp (const char );
640	extern int re_exec (const char *);
641	#endif
642
643	/* For plain 'restrict', use glibc's __restrict if defined.
644	Otherwise, GCC 2.95 and later have "__restrict"; C99 compilers have
645	"restrict", and "configure" may have defined "restrict".
646	Other compilers use __restrict, __restrict__, and _Restrict, and
647	'configure' might #define 'restrict' to those words, so pick a
648	different name. */
649	#ifndef _Restrict_
650	# if defined __restrict \
651	\|\| 2 < __GNUC__ + (95 <= __GNUC_MINOR__) \
652	\|\| __clang_major__ >= 3
653	# define _Restrict_ __restrict
654	# elif 199901L <= __STDC_VERSION__ \|\| defined restrict
655	# define _Restrict_ restrict
656	# else
657	# define _Restrict_
658	# endif
659	#endif
660	/* For the ISO C99 syntax
661	array_name[restrict]
662	use glibc's __restrict_arr if available.
663	Otherwise, GCC 3.1 and clang support this syntax (but not in C++ mode).
664	Other ISO C99 compilers support it as well. */
665	#ifndef _Restrict_arr_
666	# ifdef __restrict_arr
667	# define _Restrict_arr_ __restrict_arr
668	# elif ((199901L <= __STDC_VERSION__ \
669	\|\| 3 < __GNUC__ + (1 <= __GNUC_MINOR__) \
670	\|\| __clang_major__ >= 3) \
671	&& !defined __cplusplus)
672	# define _Restrict_arr_ _Restrict_
673	# else
674	# define _Restrict_arr_
675	# endif
676	#endif
677
678	/* POSIX compatibility. */
679	extern int regcomp (regex_t *_Restrict_ __preg,
680	const char *_Restrict_ __pattern,
681	int __cflags);
682
683	extern int regexec (const regex_t *_Restrict_ __preg,
684	const char *_Restrict_ __String, size_t __nmatch,
685	regmatch_t __pmatch[_Restrict_arr_
686	_REGEX_NELTS (__nmatch)],
687	int __eflags);
688
689	extern size_t regerror (int __errcode, const regex_t *_Restrict_ __preg,
690	char *_Restrict_ __errbuf, size_t __errbuf_size)
691	_Attr_access_ ((__write_only__, 3, 4));
692
693	extern void regfree (regex_t *__preg);
694
695	#if defined __GNUC__ && 4 < __GNUC__ + (6 <= __GNUC_MINOR__)
696	# pragma GCC diagnostic pop
697	#endif
698
699	#ifdef __cplusplus
700	}
701	#endif /* C++ */
702
703	#endif /* regex.h */

Note: See TracBrowser for help on using the repository browser.

source: kBuild/vendor/sed/current/lib/regex.h@ 3611

Download in other formats: