1 |
/* Extended regular expression matching and search library, |
/* Extended regular expression matching and search library, |
2 |
version 0.12. |
version 0.12. |
3 |
(Implements POSIX draft P10003.2/D11.2, except for |
(Implements POSIX draft P1003.2/D11.2, except for some of the |
4 |
internationalization features.) |
internationalization features.) |
5 |
|
|
6 |
Copyright (C) 1993, 1994 Free Software Foundation, Inc. |
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, |
7 |
|
2002, 2003, 2004 Free Software Foundation, Inc. |
8 |
|
|
9 |
This program is free software; you can redistribute it and/or modify |
This program is free software; you can redistribute it and/or modify |
10 |
it under the terms of the GNU General Public License as published by |
it under the terms of the GNU General Public License as published by |
16 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
17 |
GNU General Public License for more details. |
GNU General Public License for more details. |
18 |
|
|
19 |
You should have received a copy of the GNU General Public License |
You should have received a copy of the GNU General Public License along |
20 |
along with this program; if not, write to the Free Software |
with this program; if not, write to the Free Software Foundation, |
21 |
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ |
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
22 |
|
|
23 |
/* AIX requires this to be the first thing in the file. */ |
/* AIX requires this to be the first thing in the file. */ |
24 |
#if defined (_AIX) && !defined (REGEX_MALLOC) |
#if defined _AIX && !defined REGEX_MALLOC |
25 |
#pragma alloca |
#pragma alloca |
26 |
#endif |
#endif |
27 |
|
|
28 |
|
#undef _GNU_SOURCE |
29 |
#define _GNU_SOURCE |
#define _GNU_SOURCE |
30 |
|
|
31 |
#ifdef HAVE_CONFIG_H |
#ifdef HAVE_CONFIG_H |
32 |
#include <config.h> |
# include <config.h> |
33 |
#endif |
#endif |
34 |
|
|
35 |
/* We need this for `regex.h', and perhaps for the Emacs include files. */ |
#ifndef INSIDE_RECURSION |
|
#include <sys/types.h> |
|
36 |
|
|
37 |
/* The `emacs' switch turns on certain matching commands |
# include <stddef.h> |
|
that make sense only in Emacs. */ |
|
|
#ifdef emacs |
|
38 |
|
|
39 |
#include "lisp.h" |
# define WIDE_CHAR_SUPPORT (HAVE_WCTYPE_H && HAVE_WCHAR_H && HAVE_BTOWC) |
|
#include "buffer.h" |
|
|
#include "syntax.h" |
|
40 |
|
|
41 |
/* Emacs uses `NULL' as a predicate. */ |
/* For platform which support the ISO C amendement 1 functionality we |
42 |
#undef NULL |
support user defined character classes. */ |
43 |
|
# if defined _LIBC || WIDE_CHAR_SUPPORT |
44 |
#else /* not emacs */ |
/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>. */ |
45 |
|
# include <wchar.h> |
46 |
#ifdef STDC_HEADERS |
# include <wctype.h> |
47 |
#include <stdlib.h> |
# endif |
48 |
#else |
|
49 |
char *malloc (); |
# ifdef _LIBC |
50 |
char *realloc (); |
/* We have to keep the namespace clean. */ |
51 |
#endif |
# define regfree(preg) __regfree (preg) |
52 |
|
# define regexec(pr, st, nm, pm, ef) __regexec (pr, st, nm, pm, ef) |
53 |
|
# define regcomp(preg, pattern, cflags) __regcomp (preg, pattern, cflags) |
54 |
|
# define regerror(errcode, preg, errbuf, errbuf_size) \ |
55 |
|
__regerror(errcode, preg, errbuf, errbuf_size) |
56 |
|
# define re_set_registers(bu, re, nu, st, en) \ |
57 |
|
__re_set_registers (bu, re, nu, st, en) |
58 |
|
# define re_match_2(bufp, string1, size1, string2, size2, pos, regs, stop) \ |
59 |
|
__re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop) |
60 |
|
# define re_match(bufp, string, size, pos, regs) \ |
61 |
|
__re_match (bufp, string, size, pos, regs) |
62 |
|
# define re_search(bufp, string, size, startpos, range, regs) \ |
63 |
|
__re_search (bufp, string, size, startpos, range, regs) |
64 |
|
# define re_compile_pattern(pattern, length, bufp) \ |
65 |
|
__re_compile_pattern (pattern, length, bufp) |
66 |
|
# define re_set_syntax(syntax) __re_set_syntax (syntax) |
67 |
|
# define re_search_2(bufp, st1, s1, st2, s2, startpos, range, regs, stop) \ |
68 |
|
__re_search_2 (bufp, st1, s1, st2, s2, startpos, range, regs, stop) |
69 |
|
# define re_compile_fastmap(bufp) __re_compile_fastmap (bufp) |
70 |
|
|
71 |
|
# define btowc __btowc |
72 |
|
# define iswctype __iswctype |
73 |
|
# define mbrtowc __mbrtowc |
74 |
|
# define wcslen __wcslen |
75 |
|
# define wcscoll __wcscoll |
76 |
|
# define wcrtomb __wcrtomb |
77 |
|
|
78 |
|
/* We are also using some library internals. */ |
79 |
|
# include <locale/localeinfo.h> |
80 |
|
# include <locale/elem-hash.h> |
81 |
|
# include <langinfo.h> |
82 |
|
# include <locale/coll-lookup.h> |
83 |
|
# endif |
84 |
|
|
85 |
|
# ifdef _LIBC |
86 |
|
# include <libintl.h> |
87 |
|
# undef gettext |
88 |
|
# define gettext(msgid) __dcgettext ("libc", msgid, LC_MESSAGES) |
89 |
|
/* This define is so xgettext can find the internationalizable strings. */ |
90 |
|
# define gettext_noop(msgid) msgid |
91 |
|
# else |
92 |
|
# define _(text) text |
93 |
|
# define gettext_noop(text) text |
94 |
|
# endif |
95 |
|
|
96 |
|
/* Support for bounded pointers. */ |
97 |
|
# if !defined _LIBC && !defined __BOUNDED_POINTERS__ |
98 |
|
# define __bounded /* nothing */ |
99 |
|
# define __unbounded /* nothing */ |
100 |
|
# define __ptrvalue /* nothing */ |
101 |
|
# endif |
102 |
|
|
103 |
|
/* The `emacs' switch turns on certain matching commands |
104 |
|
that make sense only in Emacs. */ |
105 |
|
# ifdef emacs |
106 |
|
|
107 |
/* We used to test for `BSTRING' here, but only GCC and Emacs define |
# include "lisp.h" |
108 |
`BSTRING', as far as I know, and neither of them use this code. */ |
# include "buffer.h" |
109 |
#ifndef INHIBIT_STRING_HEADER |
# include "syntax.h" |
110 |
#if HAVE_STRING_H || STDC_HEADERS |
|
111 |
#include <string.h> |
# else /* not emacs */ |
112 |
#ifndef bcmp |
|
113 |
#define bcmp(s1, s2, n) memcmp ((s1), (s2), (n)) |
/* If we are not linking with Emacs proper, |
114 |
#endif |
we can't use the relocating allocator |
115 |
#ifndef bcopy |
even if config.h says that we can. */ |
116 |
#define bcopy(s, d, n) memcpy ((d), (s), (n)) |
# undef REL_ALLOC |
117 |
#endif |
|
118 |
#ifndef bzero |
# include <stdlib.h> |
119 |
#define bzero(s, n) memset ((s), 0, (n)) |
|
120 |
#endif |
/* When used in Emacs's lib-src, we need to get bzero and bcopy somehow. |
121 |
#else |
If nothing else has been done, use the method below. */ |
122 |
#include <strings.h> |
# ifdef INHIBIT_STRING_HEADER |
123 |
#endif |
# if !(defined HAVE_BZERO && defined HAVE_BCOPY) |
124 |
#endif |
# if !defined bzero && !defined bcopy |
125 |
|
# undef INHIBIT_STRING_HEADER |
126 |
|
# endif |
127 |
|
# endif |
128 |
|
# endif |
129 |
|
|
130 |
|
/* This is the normal way of making sure we have a bcopy and a bzero. |
131 |
|
This is used in most programs--a few other programs avoid this |
132 |
|
by defining INHIBIT_STRING_HEADER. */ |
133 |
|
# ifndef INHIBIT_STRING_HEADER |
134 |
|
# include <string.h> |
135 |
|
# ifndef bzero |
136 |
|
# ifndef _LIBC |
137 |
|
# define bzero(s, n) (memset (s, '\0', n), (s)) |
138 |
|
# else |
139 |
|
# define bzero(s, n) __bzero (s, n) |
140 |
|
# endif |
141 |
|
# endif |
142 |
|
# endif |
143 |
|
|
144 |
/* Define the syntax stuff for \<, \>, etc. */ |
/* Define the syntax stuff for \<, \>, etc. */ |
145 |
|
|
146 |
/* This must be nonzero for the wordchar and notwordchar pattern |
/* This must be nonzero for the wordchar and notwordchar pattern |
147 |
commands in re_match_2. */ |
commands in re_match_2. */ |
148 |
#ifndef Sword |
# ifndef Sword |
149 |
#define Sword 1 |
# define Sword 1 |
150 |
#endif |
# endif |
151 |
|
|
152 |
|
# ifdef SWITCH_ENUM_BUG |
153 |
|
# define SWITCH_ENUM_CAST(x) ((int)(x)) |
154 |
|
# else |
155 |
|
# define SWITCH_ENUM_CAST(x) (x) |
156 |
|
# endif |
157 |
|
|
158 |
|
# endif /* not emacs */ |
159 |
|
|
160 |
|
# include <limits.h> |
161 |
|
|
162 |
|
# ifndef MB_LEN_MAX |
163 |
|
# define MB_LEN_MAX 1 |
164 |
|
# endif |
165 |
|
|
166 |
|
/* Get the interface, including the syntax bits. */ |
167 |
|
# include <regex.h> |
168 |
|
|
169 |
#ifdef SYNTAX_TABLE |
/* isalpha etc. are used for the character classes. */ |
170 |
|
# include <ctype.h> |
171 |
|
|
172 |
extern char *re_syntax_table; |
/* Jim Meyering writes: |
173 |
|
|
174 |
#else /* not SYNTAX_TABLE */ |
"... Some ctype macros are valid only for character codes that |
175 |
|
isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when |
176 |
|
using /bin/cc or gcc but without giving an ansi option). So, all |
177 |
|
ctype uses should be through macros like ISPRINT... If |
178 |
|
STDC_HEADERS is defined, then autoconf has verified that the ctype |
179 |
|
macros don't need to be guarded with references to isascii. ... |
180 |
|
Defining isascii to 1 should let any compiler worth its salt |
181 |
|
eliminate the && through constant folding." |
182 |
|
Solaris defines some of these symbols so we must undefine them first. */ |
183 |
|
|
184 |
|
# if defined STDC_HEADERS || (!defined isascii && !defined HAVE_ISASCII) |
185 |
|
# define IN_CTYPE_DOMAIN(c) 1 |
186 |
|
# else |
187 |
|
# define IN_CTYPE_DOMAIN(c) isascii(c) |
188 |
|
# endif |
189 |
|
|
190 |
|
# ifdef isblank |
191 |
|
# define ISBLANK(c) (IN_CTYPE_DOMAIN (c) && isblank (c)) |
192 |
|
# else |
193 |
|
# define ISBLANK(c) ((c) == ' ' || (c) == '\t') |
194 |
|
# endif |
195 |
|
# ifdef isgraph |
196 |
|
# define ISGRAPH(c) (IN_CTYPE_DOMAIN (c) && isgraph (c)) |
197 |
|
# else |
198 |
|
# define ISGRAPH(c) (IN_CTYPE_DOMAIN (c) && isprint (c) && !isspace (c)) |
199 |
|
# endif |
200 |
|
|
201 |
|
# undef ISPRINT |
202 |
|
# define ISPRINT(c) (IN_CTYPE_DOMAIN (c) && isprint (c)) |
203 |
|
# define ISDIGIT(c) (IN_CTYPE_DOMAIN (c) && isdigit (c)) |
204 |
|
# define ISALNUM(c) (IN_CTYPE_DOMAIN (c) && isalnum (c)) |
205 |
|
# define ISALPHA(c) (IN_CTYPE_DOMAIN (c) && isalpha (c)) |
206 |
|
# define ISCNTRL(c) (IN_CTYPE_DOMAIN (c) && iscntrl (c)) |
207 |
|
# define ISLOWER(c) (IN_CTYPE_DOMAIN (c) && islower (c)) |
208 |
|
# define ISPUNCT(c) (IN_CTYPE_DOMAIN (c) && ispunct (c)) |
209 |
|
# define ISSPACE(c) (IN_CTYPE_DOMAIN (c) && isspace (c)) |
210 |
|
# define ISUPPER(c) (IN_CTYPE_DOMAIN (c) && isupper (c)) |
211 |
|
# define ISXDIGIT(c) (IN_CTYPE_DOMAIN (c) && isxdigit (c)) |
212 |
|
|
213 |
|
# ifdef _tolower |
214 |
|
# define TOLOWER(c) _tolower(c) |
215 |
|
# else |
216 |
|
# define TOLOWER(c) tolower(c) |
217 |
|
# endif |
218 |
|
|
219 |
|
# ifndef emacs |
220 |
/* How many characters in the character set. */ |
/* How many characters in the character set. */ |
221 |
#define CHAR_SET_SIZE 256 |
# define CHAR_SET_SIZE 256 |
222 |
|
|
223 |
|
# ifdef SYNTAX_TABLE |
224 |
|
|
225 |
|
extern char *re_syntax_table; |
226 |
|
|
227 |
|
# else /* not SYNTAX_TABLE */ |
228 |
|
|
229 |
static char re_syntax_table[CHAR_SET_SIZE]; |
static char re_syntax_table[CHAR_SET_SIZE]; |
230 |
|
|
231 |
static void |
static void |
232 |
init_syntax_once () |
init_syntax_once (void) |
233 |
{ |
{ |
234 |
register int c; |
register int c; |
235 |
static int done = 0; |
static int done = 0; |
236 |
|
|
237 |
if (done) |
if (done) |
238 |
return; |
return; |
|
|
|
239 |
bzero (re_syntax_table, sizeof re_syntax_table); |
bzero (re_syntax_table, sizeof re_syntax_table); |
240 |
|
|
241 |
for (c = 'a'; c <= 'z'; c++) |
for (c = 0; c < CHAR_SET_SIZE; ++c) |
242 |
re_syntax_table[c] = Sword; |
if (ISALNUM (c)) |
243 |
|
re_syntax_table[c] = Sword; |
|
for (c = 'A'; c <= 'Z'; c++) |
|
|
re_syntax_table[c] = Sword; |
|
|
|
|
|
for (c = '0'; c <= '9'; c++) |
|
|
re_syntax_table[c] = Sword; |
|
244 |
|
|
245 |
re_syntax_table['_'] = Sword; |
re_syntax_table['_'] = Sword; |
246 |
|
|
247 |
done = 1; |
done = 1; |
248 |
} |
} |
249 |
|
|
250 |
#endif /* not SYNTAX_TABLE */ |
# endif /* not SYNTAX_TABLE */ |
251 |
|
|
252 |
#define SYNTAX(c) re_syntax_table[c] |
# define SYNTAX(c) re_syntax_table[(unsigned char) (c)] |
253 |
|
|
254 |
#endif /* not emacs */ |
# endif /* emacs */ |
|
|
|
|
/* Get the interface, including the syntax bits. */ |
|
|
#include "regex.h" |
|
|
|
|
|
/* isalpha etc. are used for the character classes. */ |
|
|
#include <ctype.h> |
|
|
|
|
|
/* Jim Meyering writes: |
|
|
|
|
|
"... Some ctype macros are valid only for character codes that |
|
|
isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when |
|
|
using /bin/cc or gcc but without giving an ansi option). So, all |
|
|
ctype uses should be through macros like ISPRINT... If |
|
|
STDC_HEADERS is defined, then autoconf has verified that the ctype |
|
|
macros don't need to be guarded with references to isascii. ... |
|
|
Defining isascii to 1 should let any compiler worth its salt |
|
|
eliminate the && through constant folding." */ |
|
|
|
|
|
#if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII)) |
|
|
#define ISASCII(c) 1 |
|
|
#else |
|
|
#define ISASCII(c) isascii(c) |
|
|
#endif |
|
|
|
|
|
#ifdef isblank |
|
|
#define ISBLANK(c) (ISASCII (c) && isblank (c)) |
|
|
#else |
|
|
#define ISBLANK(c) ((c) == ' ' || (c) == '\t') |
|
|
#endif |
|
|
#ifdef isgraph |
|
|
#define ISGRAPH(c) (ISASCII (c) && isgraph (c)) |
|
|
#else |
|
|
#define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c)) |
|
|
#endif |
|
|
|
|
|
#define ISPRINT(c) (ISASCII (c) && isprint (c)) |
|
|
#define ISDIGIT(c) (ISASCII (c) && isdigit (c)) |
|
|
#define ISALNUM(c) (ISASCII (c) && isalnum (c)) |
|
|
#define ISALPHA(c) (ISASCII (c) && isalpha (c)) |
|
|
#define ISCNTRL(c) (ISASCII (c) && iscntrl (c)) |
|
|
#define ISLOWER(c) (ISASCII (c) && islower (c)) |
|
|
#define ISPUNCT(c) (ISASCII (c) && ispunct (c)) |
|
|
#define ISSPACE(c) (ISASCII (c) && isspace (c)) |
|
|
#define ISUPPER(c) (ISASCII (c) && isupper (c)) |
|
|
#define ISXDIGIT(c) (ISASCII (c) && isxdigit (c)) |
|
|
|
|
|
#ifndef NULL |
|
|
#define NULL 0 |
|
|
#endif |
|
|
|
|
|
/* We remove any previous definition of `SIGN_EXTEND_CHAR', |
|
|
since ours (we hope) works properly with all combinations of |
|
|
machines, compilers, `char' and `unsigned char' argument types. |
|
|
(Per Bothner suggested the basic approach.) */ |
|
|
#undef SIGN_EXTEND_CHAR |
|
|
#if __STDC__ |
|
|
#define SIGN_EXTEND_CHAR(c) ((signed char) (c)) |
|
|
#else /* not __STDC__ */ |
|
|
/* As in Harbison and Steele. */ |
|
|
#define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128) |
|
|
#endif |
|
255 |
|
|
256 |
/* Should we use malloc or alloca? If REGEX_MALLOC is not defined, we |
/* Should we use malloc or alloca? If REGEX_MALLOC is not defined, we |
257 |
use `alloca' instead of `malloc'. This is because using malloc in |
use `alloca' instead of `malloc'. This is because using malloc in |
258 |
re_search* or re_match* could cause memory leaks when C-g is used in |
re_search* or re_match* could cause memory leaks when C-g is used in |
259 |
Emacs; also, malloc is slower and causes storage fragmentation. On |
Emacs; also, malloc is slower and causes storage fragmentation. On |
260 |
the other hand, malloc is more portable, and easier to debug. |
the other hand, malloc is more portable, and easier to debug. |
261 |
|
|
262 |
Because we sometimes use alloca, some routines have to be macros, |
Because we sometimes use alloca, some routines have to be macros, |
263 |
not functions -- `alloca'-allocated space disappears at the end of the |
not functions -- `alloca'-allocated space disappears at the end of the |
264 |
function it is called in. */ |
function it is called in. */ |
265 |
|
|
266 |
#ifdef REGEX_MALLOC |
# ifdef REGEX_MALLOC |
267 |
|
|
268 |
#define REGEX_ALLOCATE malloc |
# define REGEX_ALLOCATE malloc |
269 |
#define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize) |
# define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize) |
270 |
|
# define REGEX_FREE free |
271 |
|
|
272 |
#else /* not REGEX_MALLOC */ |
# else /* not REGEX_MALLOC */ |
273 |
|
|
274 |
/* Emacs already defines alloca, sometimes. */ |
/* Emacs already defines alloca, sometimes. */ |
275 |
#ifndef alloca |
# ifndef alloca |
276 |
|
|
277 |
/* Make alloca work the best possible way. */ |
/* Make alloca work the best possible way. */ |
278 |
#ifdef __GNUC__ |
# include <alloca.h> |
|
#define alloca __builtin_alloca |
|
|
#else /* not __GNUC__ */ |
|
|
#if HAVE_ALLOCA_H |
|
|
#include <alloca.h> |
|
|
#else /* not __GNUC__ or HAVE_ALLOCA_H */ |
|
|
#ifndef _AIX /* Already did AIX, up at the top. */ |
|
|
char *alloca (); |
|
|
#endif /* not _AIX */ |
|
|
#endif /* not HAVE_ALLOCA_H */ |
|
|
#endif /* not __GNUC__ */ |
|
279 |
|
|
280 |
#endif /* not alloca */ |
# endif /* not alloca */ |
281 |
|
|
282 |
#define REGEX_ALLOCATE alloca |
# define REGEX_ALLOCATE alloca |
283 |
|
|
284 |
/* Assumes a `char *destination' variable. */ |
/* Assumes a `char *destination' variable. */ |
285 |
#define REGEX_REALLOCATE(source, osize, nsize) \ |
# define REGEX_REALLOCATE(source, osize, nsize) \ |
286 |
(destination = (char *) alloca (nsize), \ |
(destination = (char *) alloca (nsize), \ |
287 |
bcopy (source, destination, osize), \ |
memcpy (destination, source, osize)) |
288 |
destination) |
|
289 |
|
/* No need to do anything to free, after alloca. */ |
290 |
|
# define REGEX_FREE(arg) ((void)0) /* Do nothing! But inhibit gcc warning. */ |
291 |
|
|
292 |
|
# endif /* not REGEX_MALLOC */ |
293 |
|
|
294 |
|
/* Define how to allocate the failure stack. */ |
295 |
|
|
296 |
|
# if defined REL_ALLOC && defined REGEX_MALLOC |
297 |
|
|
298 |
|
# define REGEX_ALLOCATE_STACK(size) \ |
299 |
|
r_alloc (&failure_stack_ptr, (size)) |
300 |
|
# define REGEX_REALLOCATE_STACK(source, osize, nsize) \ |
301 |
|
r_re_alloc (&failure_stack_ptr, (nsize)) |
302 |
|
# define REGEX_FREE_STACK(ptr) \ |
303 |
|
r_alloc_free (&failure_stack_ptr) |
304 |
|
|
305 |
|
# else /* not using relocating allocator */ |
306 |
|
|
307 |
|
# ifdef REGEX_MALLOC |
308 |
|
|
309 |
|
# define REGEX_ALLOCATE_STACK malloc |
310 |
|
# define REGEX_REALLOCATE_STACK(source, osize, nsize) realloc (source, nsize) |
311 |
|
# define REGEX_FREE_STACK free |
312 |
|
|
313 |
|
# else /* not REGEX_MALLOC */ |
314 |
|
|
315 |
#endif /* not REGEX_MALLOC */ |
# define REGEX_ALLOCATE_STACK alloca |
316 |
|
|
317 |
|
# define REGEX_REALLOCATE_STACK(source, osize, nsize) \ |
318 |
|
REGEX_REALLOCATE (source, osize, nsize) |
319 |
|
/* No need to explicitly free anything. */ |
320 |
|
# define REGEX_FREE_STACK(arg) |
321 |
|
|
322 |
|
# endif /* not REGEX_MALLOC */ |
323 |
|
# endif /* not using relocating allocator */ |
324 |
|
|
325 |
|
|
326 |
/* True if `size1' is non-NULL and PTR is pointing anywhere inside |
/* True if `size1' is non-NULL and PTR is pointing anywhere inside |
327 |
`string1' or just past its end. This works if PTR is NULL, which is |
`string1' or just past its end. This works if PTR is NULL, which is |
328 |
a good thing. */ |
a good thing. */ |
329 |
#define FIRST_STRING_P(ptr) \ |
# define FIRST_STRING_P(ptr) \ |
330 |
(size1 && string1 <= (ptr) && (ptr) <= string1 + size1) |
(size1 && string1 <= (ptr) && (ptr) <= string1 + size1) |
331 |
|
|
332 |
/* (Re)Allocate N items of type T using malloc, or fail. */ |
/* (Re)Allocate N items of type T using malloc, or fail. */ |
333 |
#define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t))) |
# define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t))) |
334 |
#define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t))) |
# define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t))) |
335 |
#define RETALLOC_IF(addr, n, t) \ |
# define RETALLOC_IF(addr, n, t) \ |
336 |
if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t) |
if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t) |
337 |
#define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t))) |
# define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t))) |
338 |
|
|
339 |
#define BYTEWIDTH 8 /* In bits. */ |
# define BYTEWIDTH 8 /* In bits. */ |
340 |
|
|
341 |
#define STREQ(s1, s2) ((strcmp (s1, s2) == 0)) |
# define STREQ(s1, s2) ((strcmp (s1, s2) == 0)) |
342 |
|
|
343 |
#undef MAX |
# undef MAX |
344 |
#undef MIN |
# undef MIN |
345 |
#define MAX(a, b) ((a) > (b) ? (a) : (b)) |
# define MAX(a, b) ((a) > (b) ? (a) : (b)) |
346 |
#define MIN(a, b) ((a) < (b) ? (a) : (b)) |
# define MIN(a, b) ((a) < (b) ? (a) : (b)) |
347 |
|
|
348 |
typedef char boolean; |
typedef char boolean; |
349 |
#define false 0 |
# define false 0 |
350 |
#define true 1 |
# define true 1 |
351 |
|
|
352 |
static int re_match_2_internal (); |
static reg_errcode_t byte_regex_compile (const char *pattern, size_t size, |
353 |
|
reg_syntax_t syntax, |
354 |
|
struct re_pattern_buffer *bufp); |
355 |
|
|
356 |
|
static int byte_re_match_2_internal (struct re_pattern_buffer *bufp, |
357 |
|
const char *string1, int size1, |
358 |
|
const char *string2, int size2, |
359 |
|
int pos, |
360 |
|
struct re_registers *regs, |
361 |
|
int stop); |
362 |
|
static int byte_re_search_2 (struct re_pattern_buffer *bufp, |
363 |
|
const char *string1, int size1, |
364 |
|
const char *string2, int size2, |
365 |
|
int startpos, int range, |
366 |
|
struct re_registers *regs, int stop); |
367 |
|
static int byte_re_compile_fastmap (struct re_pattern_buffer *bufp); |
368 |
|
|
369 |
|
#ifdef MBS_SUPPORT |
370 |
|
static reg_errcode_t wcs_regex_compile (const char *pattern, size_t size, |
371 |
|
reg_syntax_t syntax, |
372 |
|
struct re_pattern_buffer *bufp); |
373 |
|
|
374 |
|
|
375 |
|
static int wcs_re_match_2_internal (struct re_pattern_buffer *bufp, |
376 |
|
const char *cstring1, int csize1, |
377 |
|
const char *cstring2, int csize2, |
378 |
|
int pos, |
379 |
|
struct re_registers *regs, |
380 |
|
int stop, |
381 |
|
wchar_t *string1, int size1, |
382 |
|
wchar_t *string2, int size2, |
383 |
|
int *mbs_offset1, int *mbs_offset2); |
384 |
|
static int wcs_re_search_2 (struct re_pattern_buffer *bufp, |
385 |
|
const char *string1, int size1, |
386 |
|
const char *string2, int size2, |
387 |
|
int startpos, int range, |
388 |
|
struct re_registers *regs, int stop); |
389 |
|
static int wcs_re_compile_fastmap (struct re_pattern_buffer *bufp); |
390 |
|
#endif |
391 |
|
|
392 |
/* These are the command codes that appear in compiled regular |
/* These are the command codes that appear in compiled regular |
393 |
expressions. Some opcodes are followed by argument bytes. A |
expressions. Some opcodes are followed by argument bytes. A |
398 |
{ |
{ |
399 |
no_op = 0, |
no_op = 0, |
400 |
|
|
401 |
|
/* Succeed right away--no more backtracking. */ |
402 |
|
succeed, |
403 |
|
|
404 |
/* Followed by one byte giving n, then by n literal bytes. */ |
/* Followed by one byte giving n, then by n literal bytes. */ |
405 |
exactn, |
exactn, |
406 |
|
|
407 |
|
# ifdef MBS_SUPPORT |
408 |
|
/* Same as exactn, but contains binary data. */ |
409 |
|
exactn_bin, |
410 |
|
# endif |
411 |
|
|
412 |
/* Matches any (more or less) character. */ |
/* Matches any (more or less) character. */ |
413 |
anychar, |
anychar, |
414 |
|
|
418 |
are ordered low-bit-first. A character is in the set if its |
are ordered low-bit-first. A character is in the set if its |
419 |
bit is 1. A character too large to have a bit in the map is |
bit is 1. A character too large to have a bit in the map is |
420 |
automatically not in the set. */ |
automatically not in the set. */ |
421 |
|
/* ifdef MBS_SUPPORT, following element is length of character |
422 |
|
classes, length of collating symbols, length of equivalence |
423 |
|
classes, length of character ranges, and length of characters. |
424 |
|
Next, character class element, collating symbols elements, |
425 |
|
equivalence class elements, range elements, and character |
426 |
|
elements follow. |
427 |
|
See regex_compile function. */ |
428 |
charset, |
charset, |
429 |
|
|
430 |
/* Same parameters as charset, but match any character that is |
/* Same parameters as charset, but match any character that is |
465 |
|
|
466 |
/* Analogously, for end of buffer/string. */ |
/* Analogously, for end of buffer/string. */ |
467 |
endbuf, |
endbuf, |
468 |
|
|
469 |
/* Followed by two byte relative address to which to jump. */ |
/* Followed by two byte relative address to which to jump. */ |
470 |
jump, |
jump, |
471 |
|
|
472 |
/* Same as jump, but marks the end of an alternative. */ |
/* Same as jump, but marks the end of an alternative. */ |
473 |
jump_past_alt, |
jump_past_alt, |
474 |
|
|
475 |
/* Followed by two-byte relative address of place to resume at |
/* Followed by two-byte relative address of place to resume at |
476 |
in case of failure. */ |
in case of failure. */ |
477 |
|
/* ifdef MBS_SUPPORT, the size of address is 1. */ |
478 |
on_failure_jump, |
on_failure_jump, |
479 |
|
|
480 |
/* Like on_failure_jump, but pushes a placeholder instead of the |
/* Like on_failure_jump, but pushes a placeholder instead of the |
481 |
current string position when executed. */ |
current string position when executed. */ |
482 |
on_failure_keep_string_jump, |
on_failure_keep_string_jump, |
483 |
|
|
484 |
/* Throw away latest failure point and then jump to following |
/* Throw away latest failure point and then jump to following |
485 |
two-byte relative address. */ |
two-byte relative address. */ |
486 |
|
/* ifdef MBS_SUPPORT, the size of address is 1. */ |
487 |
pop_failure_jump, |
pop_failure_jump, |
488 |
|
|
489 |
/* Change to pop_failure_jump if know won't have to backtrack to |
/* Change to pop_failure_jump if know won't have to backtrack to |
493 |
sure that there is no use backtracking out of repetitions |
sure that there is no use backtracking out of repetitions |
494 |
already matched, then we change it to a pop_failure_jump. |
already matched, then we change it to a pop_failure_jump. |
495 |
Followed by two-byte address. */ |
Followed by two-byte address. */ |
496 |
|
/* ifdef MBS_SUPPORT, the size of address is 1. */ |
497 |
maybe_pop_jump, |
maybe_pop_jump, |
498 |
|
|
499 |
/* Jump to following two-byte address, and push a dummy failure |
/* Jump to following two-byte address, and push a dummy failure |
501 |
is made to use it for a failure. A `+' construct makes this |
is made to use it for a failure. A `+' construct makes this |
502 |
before the first repeat. Also used as an intermediary kind |
before the first repeat. Also used as an intermediary kind |
503 |
of jump when compiling an alternative. */ |
of jump when compiling an alternative. */ |
504 |
|
/* ifdef MBS_SUPPORT, the size of address is 1. */ |
505 |
dummy_failure_jump, |
dummy_failure_jump, |
506 |
|
|
507 |
/* Push a dummy failure point and continue. Used at the end of |
/* Push a dummy failure point and continue. Used at the end of |
510 |
|
|
511 |
/* Followed by two-byte relative address and two-byte number n. |
/* Followed by two-byte relative address and two-byte number n. |
512 |
After matching N times, jump to the address upon failure. */ |
After matching N times, jump to the address upon failure. */ |
513 |
|
/* ifdef MBS_SUPPORT, the size of address is 1. */ |
514 |
succeed_n, |
succeed_n, |
515 |
|
|
516 |
/* Followed by two-byte relative address, and two-byte number n. |
/* Followed by two-byte relative address, and two-byte number n. |
517 |
Jump to the address N times, then fail. */ |
Jump to the address N times, then fail. */ |
518 |
|
/* ifdef MBS_SUPPORT, the size of address is 1. */ |
519 |
jump_n, |
jump_n, |
520 |
|
|
521 |
/* Set the following two-byte relative address to the |
/* Set the following two-byte relative address to the |
522 |
subsequent two-byte number. The address *includes* the two |
subsequent two-byte number. The address *includes* the two |
523 |
bytes of number. */ |
bytes of number. */ |
524 |
|
/* ifdef MBS_SUPPORT, the size of address is 1. */ |
525 |
set_number_at, |
set_number_at, |
526 |
|
|
527 |
wordchar, /* Matches any word-constituent character. */ |
wordchar, /* Matches any word-constituent character. */ |
533 |
wordbound, /* Succeeds if at a word boundary. */ |
wordbound, /* Succeeds if at a word boundary. */ |
534 |
notwordbound /* Succeeds if not at a word boundary. */ |
notwordbound /* Succeeds if not at a word boundary. */ |
535 |
|
|
536 |
#ifdef emacs |
# ifdef emacs |
537 |
,before_dot, /* Succeeds if before point. */ |
,before_dot, /* Succeeds if before point. */ |
538 |
at_dot, /* Succeeds if at point. */ |
at_dot, /* Succeeds if at point. */ |
539 |
after_dot, /* Succeeds if after point. */ |
after_dot, /* Succeeds if after point. */ |
544 |
|
|
545 |
/* Matches any character whose syntax is not that specified. */ |
/* Matches any character whose syntax is not that specified. */ |
546 |
notsyntaxspec |
notsyntaxspec |
547 |
#endif /* emacs */ |
# endif /* emacs */ |
548 |
} re_opcode_t; |
} re_opcode_t; |
549 |
|
#endif /* not INSIDE_RECURSION */ |
550 |
|
|
551 |
|
|
552 |
|
#ifdef BYTE |
553 |
|
# define CHAR_T char |
554 |
|
# define UCHAR_T unsigned char |
555 |
|
# define COMPILED_BUFFER_VAR bufp->buffer |
556 |
|
# define OFFSET_ADDRESS_SIZE 2 |
557 |
|
# define PREFIX(name) byte_##name |
558 |
|
# define ARG_PREFIX(name) name |
559 |
|
# define PUT_CHAR(c) putchar (c) |
560 |
|
#else |
561 |
|
# ifdef WCHAR |
562 |
|
# define CHAR_T wchar_t |
563 |
|
# define UCHAR_T wchar_t |
564 |
|
# define COMPILED_BUFFER_VAR wc_buffer |
565 |
|
# define OFFSET_ADDRESS_SIZE 1 /* the size which STORE_NUMBER macro use */ |
566 |
|
# define CHAR_CLASS_SIZE ((__alignof__(wctype_t)+sizeof(wctype_t))/sizeof(CHAR_T)+1) |
567 |
|
# define PREFIX(name) wcs_##name |
568 |
|
# define ARG_PREFIX(name) c##name |
569 |
|
/* Should we use wide stream?? */ |
570 |
|
# define PUT_CHAR(c) printf ("%C", c); |
571 |
|
# define TRUE 1 |
572 |
|
# define FALSE 0 |
573 |
|
# else |
574 |
|
# ifdef MBS_SUPPORT |
575 |
|
# define WCHAR |
576 |
|
# define INSIDE_RECURSION |
577 |
|
# include "regex.c" |
578 |
|
# undef INSIDE_RECURSION |
579 |
|
# endif |
580 |
|
# define BYTE |
581 |
|
# define INSIDE_RECURSION |
582 |
|
# include "regex.c" |
583 |
|
# undef INSIDE_RECURSION |
584 |
|
# endif |
585 |
|
#endif |
586 |
|
|
587 |
|
#if USE_UNLOCKED_IO |
588 |
|
# include "unlocked-io.h" |
589 |
|
#endif |
590 |
|
|
591 |
|
#ifdef INSIDE_RECURSION |
592 |
/* Common operations on the compiled pattern. */ |
/* Common operations on the compiled pattern. */ |
593 |
|
|
594 |
/* Store NUMBER in two contiguous bytes starting at DESTINATION. */ |
/* Store NUMBER in two contiguous bytes starting at DESTINATION. */ |
595 |
|
/* ifdef MBS_SUPPORT, we store NUMBER in 1 element. */ |
596 |
|
|
597 |
#define STORE_NUMBER(destination, number) \ |
# ifdef WCHAR |
598 |
|
# define STORE_NUMBER(destination, number) \ |
599 |
|
do { \ |
600 |
|
*(destination) = (UCHAR_T)(number); \ |
601 |
|
} while (0) |
602 |
|
# else /* BYTE */ |
603 |
|
# define STORE_NUMBER(destination, number) \ |
604 |
do { \ |
do { \ |
605 |
(destination)[0] = (number) & 0377; \ |
(destination)[0] = (number) & 0377; \ |
606 |
(destination)[1] = (number) >> 8; \ |
(destination)[1] = (number) >> 8; \ |
607 |
} while (0) |
} while (0) |
608 |
|
# endif /* WCHAR */ |
609 |
|
|
610 |
/* Same as STORE_NUMBER, except increment DESTINATION to |
/* Same as STORE_NUMBER, except increment DESTINATION to |
611 |
the byte after where the number is stored. Therefore, DESTINATION |
the byte after where the number is stored. Therefore, DESTINATION |
612 |
must be an lvalue. */ |
must be an lvalue. */ |
613 |
|
/* ifdef MBS_SUPPORT, we store NUMBER in 1 element. */ |
614 |
|
|
615 |
#define STORE_NUMBER_AND_INCR(destination, number) \ |
# define STORE_NUMBER_AND_INCR(destination, number) \ |
616 |
do { \ |
do { \ |
617 |
STORE_NUMBER (destination, number); \ |
STORE_NUMBER (destination, number); \ |
618 |
(destination) += 2; \ |
(destination) += OFFSET_ADDRESS_SIZE; \ |
619 |
} while (0) |
} while (0) |
620 |
|
|
621 |
/* Put into DESTINATION a number stored in two contiguous bytes starting |
/* Put into DESTINATION a number stored in two contiguous bytes starting |
622 |
at SOURCE. */ |
at SOURCE. */ |
623 |
|
/* ifdef MBS_SUPPORT, we store NUMBER in 1 element. */ |
624 |
|
|
625 |
#define EXTRACT_NUMBER(destination, source) \ |
# ifdef WCHAR |
626 |
|
# define EXTRACT_NUMBER(destination, source) \ |
627 |
|
do { \ |
628 |
|
(destination) = *(source); \ |
629 |
|
} while (0) |
630 |
|
# else /* BYTE */ |
631 |
|
# define EXTRACT_NUMBER(destination, source) \ |
632 |
do { \ |
do { \ |
633 |
(destination) = *(source) & 0377; \ |
(destination) = *(source) & 0377; \ |
634 |
(destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8; \ |
(destination) += (signed char) (*((source) + 1)) << 8; \ |
635 |
} while (0) |
} while (0) |
636 |
|
# endif |
637 |
|
|
638 |
#ifdef DEBUG |
# ifdef DEBUG |
639 |
static void |
static void |
640 |
extract_number (dest, source) |
PREFIX(extract_number) (int *dest, UCHAR_T *source) |
|
int *dest; |
|
|
unsigned char *source; |
|
641 |
{ |
{ |
642 |
int temp = SIGN_EXTEND_CHAR (*(source + 1)); |
# ifdef WCHAR |
643 |
|
*dest = *source; |
644 |
|
# else /* BYTE */ |
645 |
|
signed char temp = source[1]; |
646 |
*dest = *source & 0377; |
*dest = *source & 0377; |
647 |
*dest += temp << 8; |
*dest += temp << 8; |
648 |
|
# endif |
649 |
} |
} |
650 |
|
|
651 |
#ifndef EXTRACT_MACROS /* To debug the macros. */ |
# ifndef EXTRACT_MACROS /* To debug the macros. */ |
652 |
#undef EXTRACT_NUMBER |
# undef EXTRACT_NUMBER |
653 |
#define EXTRACT_NUMBER(dest, src) extract_number (&dest, src) |
# define EXTRACT_NUMBER(dest, src) PREFIX(extract_number) (&dest, src) |
654 |
#endif /* not EXTRACT_MACROS */ |
# endif /* not EXTRACT_MACROS */ |
655 |
|
|
656 |
#endif /* DEBUG */ |
# endif /* DEBUG */ |
657 |
|
|
658 |
/* Same as EXTRACT_NUMBER, except increment SOURCE to after the number. |
/* Same as EXTRACT_NUMBER, except increment SOURCE to after the number. |
659 |
SOURCE must be an lvalue. */ |
SOURCE must be an lvalue. */ |
660 |
|
|
661 |
#define EXTRACT_NUMBER_AND_INCR(destination, source) \ |
# define EXTRACT_NUMBER_AND_INCR(destination, source) \ |
662 |
do { \ |
do { \ |
663 |
EXTRACT_NUMBER (destination, source); \ |
EXTRACT_NUMBER (destination, source); \ |
664 |
(source) += 2; \ |
(source) += OFFSET_ADDRESS_SIZE; \ |
665 |
} while (0) |
} while (0) |
666 |
|
|
667 |
#ifdef DEBUG |
# ifdef DEBUG |
668 |
static void |
static void |
669 |
extract_number_and_incr (destination, source) |
PREFIX(extract_number_and_incr) (int *destination, UCHAR_T **source) |
670 |
int *destination; |
{ |
671 |
unsigned char **source; |
PREFIX(extract_number) (destination, *source); |
672 |
{ |
*source += OFFSET_ADDRESS_SIZE; |
|
extract_number (destination, *source); |
|
|
*source += 2; |
|
673 |
} |
} |
674 |
|
|
675 |
#ifndef EXTRACT_MACROS |
# ifndef EXTRACT_MACROS |
676 |
#undef EXTRACT_NUMBER_AND_INCR |
# undef EXTRACT_NUMBER_AND_INCR |
677 |
#define EXTRACT_NUMBER_AND_INCR(dest, src) \ |
# define EXTRACT_NUMBER_AND_INCR(dest, src) \ |
678 |
extract_number_and_incr (&dest, &src) |
PREFIX(extract_number_and_incr) (&dest, &src) |
679 |
#endif /* not EXTRACT_MACROS */ |
# endif /* not EXTRACT_MACROS */ |
680 |
|
|
681 |
|
# endif /* DEBUG */ |
682 |
|
|
|
#endif /* DEBUG */ |
|
683 |
|
|
684 |
|
|
685 |
/* If DEBUG is defined, Regex prints many voluminous messages about what |
/* If DEBUG is defined, Regex prints many voluminous messages about what |
686 |
it is doing (if the variable `debug' is nonzero). If linked with the |
it is doing (if the variable `debug' is nonzero). If linked with the |
687 |
main program in `iregex.c', you can enter patterns and strings |
main program in `iregex.c', you can enter patterns and strings |
688 |
interactively. And if linked with the main program in `main.c' and |
interactively. And if linked with the main program in `main.c' and |
689 |
the other test files, you can run the already-written tests. */ |
the other test files, you can run the already-written tests. */ |
690 |
|
|
691 |
#ifdef DEBUG |
# ifdef DEBUG |
692 |
|
|
693 |
|
# ifndef DEFINED_ONCE |
694 |
|
|
695 |
/* We use standard I/O for debugging. */ |
/* We use standard I/O for debugging. */ |
696 |
#include <stdio.h> |
# include <stdio.h> |
697 |
|
|
698 |
/* It is useful to test things that ``must'' be true when debugging. */ |
/* It is useful to test things that ``must'' be true when debugging. */ |
699 |
#include <assert.h> |
# include <assert.h> |
|
|
|
|
static int debug = 0; |
|
700 |
|
|
701 |
#define DEBUG_STATEMENT(e) e |
static int debug; |
|
#define DEBUG_PRINT1(x) if (debug) printf (x) |
|
|
#define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2) |
|
|
#define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3) |
|
|
#define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4) |
|
|
#define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) \ |
|
|
if (debug) print_partial_compiled_pattern (s, e) |
|
|
#define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) \ |
|
|
if (debug) print_double_string (w, s1, sz1, s2, sz2) |
|
702 |
|
|
703 |
|
# define DEBUG_STATEMENT(e) e |
704 |
|
# define DEBUG_PRINT1(x) if (debug) printf (x) |
705 |
|
# define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2) |
706 |
|
# define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3) |
707 |
|
# define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4) |
708 |
|
# endif /* not DEFINED_ONCE */ |
709 |
|
|
710 |
|
# define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) \ |
711 |
|
if (debug) PREFIX(print_partial_compiled_pattern) (s, e) |
712 |
|
# define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) \ |
713 |
|
if (debug) PREFIX(print_double_string) (w, s1, sz1, s2, sz2) |
714 |
|
|
|
extern void printchar (); |
|
715 |
|
|
716 |
/* Print the fastmap in human-readable form. */ |
/* Print the fastmap in human-readable form. */ |
717 |
|
|
718 |
|
# ifndef DEFINED_ONCE |
719 |
void |
void |
720 |
print_fastmap (fastmap) |
print_fastmap (char *fastmap) |
|
char *fastmap; |
|
721 |
{ |
{ |
722 |
unsigned was_a_range = 0; |
unsigned was_a_range = 0; |
723 |
unsigned i = 0; |
unsigned i = 0; |
724 |
|
|
725 |
while (i < (1 << BYTEWIDTH)) |
while (i < (1 << BYTEWIDTH)) |
726 |
{ |
{ |
727 |
if (fastmap[i++]) |
if (fastmap[i++]) |
728 |
{ |
{ |
729 |
was_a_range = 0; |
was_a_range = 0; |
730 |
printchar (i - 1); |
putchar (i - 1); |
731 |
while (i < (1 << BYTEWIDTH) && fastmap[i]) |
while (i < (1 << BYTEWIDTH) && fastmap[i]) |
732 |
{ |
{ |
733 |
was_a_range = 1; |
was_a_range = 1; |
736 |
if (was_a_range) |
if (was_a_range) |
737 |
{ |
{ |
738 |
printf ("-"); |
printf ("-"); |
739 |
printchar (i - 1); |
putchar (i - 1); |
740 |
} |
} |
741 |
} |
} |
742 |
} |
} |
743 |
putchar ('\n'); |
putchar ('\n'); |
744 |
} |
} |
745 |
|
# endif /* not DEFINED_ONCE */ |
746 |
|
|
747 |
|
|
748 |
/* Print a compiled pattern string in human-readable form, starting at |
/* Print a compiled pattern string in human-readable form, starting at |
749 |
the START pointer into it and ending just before the pointer END. */ |
the START pointer into it and ending just before the pointer END. */ |
750 |
|
|
751 |
void |
void |
752 |
print_partial_compiled_pattern (start, end) |
PREFIX(print_partial_compiled_pattern) (UCHAR_T *start, UCHAR_T *end) |
|
unsigned char *start; |
|
|
unsigned char *end; |
|
753 |
{ |
{ |
754 |
int mcnt, mcnt2; |
int mcnt, mcnt2; |
755 |
unsigned char *p = start; |
UCHAR_T *p1; |
756 |
unsigned char *pend = end; |
UCHAR_T *p = start; |
757 |
|
UCHAR_T *pend = end; |
758 |
|
|
759 |
if (start == NULL) |
if (start == NULL) |
760 |
{ |
{ |
761 |
printf ("(null)\n"); |
printf ("(null)\n"); |
762 |
return; |
return; |
763 |
} |
} |
764 |
|
|
765 |
/* Loop over pattern commands. */ |
/* Loop over pattern commands. */ |
766 |
while (p < pend) |
while (p < pend) |
767 |
{ |
{ |
768 |
printf ("%d:\t", p - start); |
# ifdef _LIBC |
769 |
|
printf ("%td:\t", p - start); |
770 |
|
# else |
771 |
|
printf ("%ld:\t", (long int) (p - start)); |
772 |
|
# endif |
773 |
|
|
774 |
switch ((re_opcode_t) *p++) |
switch ((re_opcode_t) *p++) |
775 |
{ |
{ |
783 |
do |
do |
784 |
{ |
{ |
785 |
putchar ('/'); |
putchar ('/'); |
786 |
printchar (*p++); |
PUT_CHAR (*p++); |
787 |
} |
} |
788 |
while (--mcnt); |
while (--mcnt); |
789 |
break; |
break; |
790 |
|
|
791 |
|
# ifdef MBS_SUPPORT |
792 |
|
case exactn_bin: |
793 |
|
mcnt = *p++; |
794 |
|
printf ("/exactn_bin/%d", mcnt); |
795 |
|
do |
796 |
|
{ |
797 |
|
printf("/%lx", (long int) *p++); |
798 |
|
} |
799 |
|
while (--mcnt); |
800 |
|
break; |
801 |
|
# endif /* MBS_SUPPORT */ |
802 |
|
|
803 |
case start_memory: |
case start_memory: |
804 |
mcnt = *p++; |
mcnt = *p++; |
805 |
printf ("/start_memory/%d/%d", mcnt, *p++); |
printf ("/start_memory/%d/%ld", mcnt, (long int) *p++); |
806 |
break; |
break; |
807 |
|
|
808 |
case stop_memory: |
case stop_memory: |
809 |
mcnt = *p++; |
mcnt = *p++; |
810 |
printf ("/stop_memory/%d/%d", mcnt, *p++); |
printf ("/stop_memory/%d/%ld", mcnt, (long int) *p++); |
811 |
break; |
break; |
812 |
|
|
813 |
case duplicate: |
case duplicate: |
814 |
printf ("/duplicate/%d", *p++); |
printf ("/duplicate/%ld", (long int) *p++); |
815 |
break; |
break; |
816 |
|
|
817 |
case anychar: |
case anychar: |
821 |
case charset: |
case charset: |
822 |
case charset_not: |
case charset_not: |
823 |
{ |
{ |
824 |
|
# ifdef WCHAR |
825 |
|
int i, length; |
826 |
|
wchar_t *workp = p; |
827 |
|
printf ("/charset [%s", |
828 |
|
(re_opcode_t) *(workp - 1) == charset_not ? "^" : ""); |
829 |
|
p += 5; |
830 |
|
length = *workp++; /* the length of char_classes */ |
831 |
|
for (i=0 ; i<length ; i++) |
832 |
|
printf("[:%lx:]", (long int) *p++); |
833 |
|
length = *workp++; /* the length of collating_symbol */ |
834 |
|
for (i=0 ; i<length ;) |
835 |
|
{ |
836 |
|
printf("[."); |
837 |
|
while(*p != 0) |
838 |
|
PUT_CHAR((i++,*p++)); |
839 |
|
i++,p++; |
840 |
|
printf(".]"); |
841 |
|
} |
842 |
|
length = *workp++; /* the length of equivalence_class */ |
843 |
|
for (i=0 ; i<length ;) |
844 |
|
{ |
845 |
|
printf("[="); |
846 |
|
while(*p != 0) |
847 |
|
PUT_CHAR((i++,*p++)); |
848 |
|
i++,p++; |
849 |
|
printf("=]"); |
850 |
|
} |
851 |
|
length = *workp++; /* the length of char_range */ |
852 |
|
for (i=0 ; i<length ; i++) |
853 |
|
{ |
854 |
|
wchar_t range_start = *p++; |
855 |
|
wchar_t range_end = *p++; |
856 |
|
printf("%C-%C", range_start, range_end); |
857 |
|
} |
858 |
|
length = *workp++; /* the length of char */ |
859 |
|
for (i=0 ; i<length ; i++) |
860 |
|
printf("%C", *p++); |
861 |
|
putchar (']'); |
862 |
|
# else |
863 |
register int c, last = -100; |
register int c, last = -100; |
864 |
register int in_range = 0; |
register int in_range = 0; |
865 |
|
|
866 |
printf ("/charset [%s", |
printf ("/charset [%s", |
867 |
(re_opcode_t) *(p - 1) == charset_not ? "^" : ""); |
(re_opcode_t) *(p - 1) == charset_not ? "^" : ""); |
868 |
|
|
869 |
assert (p + *p < pend); |
assert (p + *p < pend); |
870 |
|
|
871 |
for (c = 0; c < 256; c++) |
for (c = 0; c < 256; c++) |
881 |
/* Have we broken a range? */ |
/* Have we broken a range? */ |
882 |
else if (last + 1 != c && in_range) |
else if (last + 1 != c && in_range) |
883 |
{ |
{ |
884 |
printchar (last); |
putchar (last); |
885 |
in_range = 0; |
in_range = 0; |
886 |
} |
} |
887 |
|
|
888 |
if (! in_range) |
if (! in_range) |
889 |
printchar (c); |
putchar (c); |
890 |
|
|
891 |
last = c; |
last = c; |
892 |
} |
} |
893 |
|
|
894 |
if (in_range) |
if (in_range) |
895 |
printchar (last); |
putchar (last); |
896 |
|
|
897 |
putchar (']'); |
putchar (']'); |
898 |
|
|
899 |
p += 1 + *p; |
p += 1 + *p; |
900 |
|
# endif /* WCHAR */ |
901 |
} |
} |
902 |
break; |
break; |
903 |
|
|
910 |
break; |
break; |
911 |
|
|
912 |
case on_failure_jump: |
case on_failure_jump: |
913 |
extract_number_and_incr (&mcnt, &p); |
PREFIX(extract_number_and_incr) (&mcnt, &p); |
914 |
printf ("/on_failure_jump to %d", p + mcnt - start); |
# ifdef _LIBC |
915 |
|
printf ("/on_failure_jump to %td", p + mcnt - start); |
916 |
|
# else |
917 |
|
printf ("/on_failure_jump to %ld", (long int) (p + mcnt - start)); |
918 |
|
# endif |
919 |
break; |
break; |
920 |
|
|
921 |
case on_failure_keep_string_jump: |
case on_failure_keep_string_jump: |
922 |
extract_number_and_incr (&mcnt, &p); |
PREFIX(extract_number_and_incr) (&mcnt, &p); |
923 |
printf ("/on_failure_keep_string_jump to %d", p + mcnt - start); |
# ifdef _LIBC |
924 |
|
printf ("/on_failure_keep_string_jump to %td", p + mcnt - start); |
925 |
|
# else |
926 |
|
printf ("/on_failure_keep_string_jump to %ld", |
927 |
|
(long int) (p + mcnt - start)); |
928 |
|
# endif |
929 |
break; |
break; |
930 |
|
|
931 |
case dummy_failure_jump: |
case dummy_failure_jump: |
932 |
extract_number_and_incr (&mcnt, &p); |
PREFIX(extract_number_and_incr) (&mcnt, &p); |
933 |
printf ("/dummy_failure_jump to %d", p + mcnt - start); |
# ifdef _LIBC |
934 |
|
printf ("/dummy_failure_jump to %td", p + mcnt - start); |
935 |
|
# else |
936 |
|
printf ("/dummy_failure_jump to %ld", (long int) (p + mcnt - start)); |
937 |
|
# endif |
938 |
break; |
break; |
939 |
|
|
940 |
case push_dummy_failure: |
case push_dummy_failure: |
941 |
printf ("/push_dummy_failure"); |
printf ("/push_dummy_failure"); |
942 |
break; |
break; |
943 |
|
|
944 |
case maybe_pop_jump: |
case maybe_pop_jump: |
945 |
extract_number_and_incr (&mcnt, &p); |
PREFIX(extract_number_and_incr) (&mcnt, &p); |
946 |
printf ("/maybe_pop_jump to %d", p + mcnt - start); |
# ifdef _LIBC |
947 |
|
printf ("/maybe_pop_jump to %td", p + mcnt - start); |
948 |
|
# else |
949 |
|
printf ("/maybe_pop_jump to %ld", (long int) (p + mcnt - start)); |
950 |
|
# endif |
951 |
break; |
break; |
952 |
|
|
953 |
case pop_failure_jump: |
case pop_failure_jump: |
954 |
extract_number_and_incr (&mcnt, &p); |
PREFIX(extract_number_and_incr) (&mcnt, &p); |
955 |
printf ("/pop_failure_jump to %d", p + mcnt - start); |
# ifdef _LIBC |
956 |
break; |
printf ("/pop_failure_jump to %td", p + mcnt - start); |
957 |
|
# else |
958 |
|
printf ("/pop_failure_jump to %ld", (long int) (p + mcnt - start)); |
959 |
|
# endif |
960 |
|
break; |
961 |
|
|
962 |
case jump_past_alt: |
case jump_past_alt: |
963 |
extract_number_and_incr (&mcnt, &p); |
PREFIX(extract_number_and_incr) (&mcnt, &p); |
964 |
printf ("/jump_past_alt to %d", p + mcnt - start); |
# ifdef _LIBC |
965 |
break; |
printf ("/jump_past_alt to %td", p + mcnt - start); |
966 |
|
# else |
967 |
|
printf ("/jump_past_alt to %ld", (long int) (p + mcnt - start)); |
968 |
|
# endif |
969 |
|
break; |
970 |
|
|
971 |
case jump: |
case jump: |
972 |
extract_number_and_incr (&mcnt, &p); |
PREFIX(extract_number_and_incr) (&mcnt, &p); |
973 |
printf ("/jump to %d", p + mcnt - start); |
# ifdef _LIBC |
974 |
|
printf ("/jump to %td", p + mcnt - start); |
975 |
|
# else |
976 |
|
printf ("/jump to %ld", (long int) (p + mcnt - start)); |
977 |
|
# endif |
978 |
break; |
break; |
979 |
|
|
980 |
case succeed_n: |
case succeed_n: |
981 |
extract_number_and_incr (&mcnt, &p); |
PREFIX(extract_number_and_incr) (&mcnt, &p); |
982 |
extract_number_and_incr (&mcnt2, &p); |
p1 = p + mcnt; |
983 |
printf ("/succeed_n to %d, %d times", p + mcnt - start, mcnt2); |
PREFIX(extract_number_and_incr) (&mcnt2, &p); |
984 |
|
# ifdef _LIBC |
985 |
|
printf ("/succeed_n to %td, %d times", p1 - start, mcnt2); |
986 |
|
# else |
987 |
|
printf ("/succeed_n to %ld, %d times", |
988 |
|
(long int) (p1 - start), mcnt2); |
989 |
|
# endif |
990 |
break; |
break; |
991 |
|
|
992 |
case jump_n: |
case jump_n: |
993 |
extract_number_and_incr (&mcnt, &p); |
PREFIX(extract_number_and_incr) (&mcnt, &p); |
994 |
extract_number_and_incr (&mcnt2, &p); |
p1 = p + mcnt; |
995 |
printf ("/jump_n to %d, %d times", p + mcnt - start, mcnt2); |
PREFIX(extract_number_and_incr) (&mcnt2, &p); |
996 |
|
printf ("/jump_n to %d, %d times", p1 - start, mcnt2); |
997 |
break; |
break; |
998 |
|
|
999 |
case set_number_at: |
case set_number_at: |
1000 |
extract_number_and_incr (&mcnt, &p); |
PREFIX(extract_number_and_incr) (&mcnt, &p); |
1001 |
extract_number_and_incr (&mcnt2, &p); |
p1 = p + mcnt; |
1002 |
printf ("/set_number_at location %d to %d", p + mcnt - start, mcnt2); |
PREFIX(extract_number_and_incr) (&mcnt2, &p); |
1003 |
|
# ifdef _LIBC |
1004 |
|
printf ("/set_number_at location %td to %d", p1 - start, mcnt2); |
1005 |
|
# else |
1006 |
|
printf ("/set_number_at location %ld to %d", |
1007 |
|
(long int) (p1 - start), mcnt2); |
1008 |
|
# endif |
1009 |
break; |
break; |
1010 |
|
|
1011 |
case wordbound: |
case wordbound: |
1012 |
printf ("/wordbound"); |
printf ("/wordbound"); |
1013 |
break; |
break; |
1019 |
case wordbeg: |
case wordbeg: |
1020 |
printf ("/wordbeg"); |
printf ("/wordbeg"); |
1021 |
break; |
break; |
1022 |
|
|
1023 |
case wordend: |
case wordend: |
1024 |
printf ("/wordend"); |
printf ("/wordend"); |
1025 |
|
break; |
1026 |
#ifdef emacs |
|
1027 |
|
# ifdef emacs |
1028 |
case before_dot: |
case before_dot: |
1029 |
printf ("/before_dot"); |
printf ("/before_dot"); |
1030 |
break; |
break; |
1042 |
mcnt = *p++; |
mcnt = *p++; |
1043 |
printf ("/%d", mcnt); |
printf ("/%d", mcnt); |
1044 |
break; |
break; |
1045 |
|
|
1046 |
case notsyntaxspec: |
case notsyntaxspec: |
1047 |
printf ("/notsyntaxspec"); |
printf ("/notsyntaxspec"); |
1048 |
mcnt = *p++; |
mcnt = *p++; |
1049 |
printf ("/%d", mcnt); |
printf ("/%d", mcnt); |
1050 |
break; |
break; |
1051 |
#endif /* emacs */ |
# endif /* emacs */ |
1052 |
|
|
1053 |
case wordchar: |
case wordchar: |
1054 |
printf ("/wordchar"); |
printf ("/wordchar"); |
1055 |
break; |
break; |
1056 |
|
|
1057 |
case notwordchar: |
case notwordchar: |
1058 |
printf ("/notwordchar"); |
printf ("/notwordchar"); |
1059 |
break; |
break; |
1067 |
break; |
break; |
1068 |
|
|
1069 |
default: |
default: |
1070 |
printf ("?%d", *(p-1)); |
printf ("?%ld", (long int) *(p-1)); |
1071 |
} |
} |
1072 |
|
|
1073 |
putchar ('\n'); |
putchar ('\n'); |
1074 |
} |
} |
1075 |
|
|
1076 |
printf ("%d:\tend of pattern.\n", p - start); |
# ifdef _LIBC |
1077 |
|
printf ("%td:\tend of pattern.\n", p - start); |
1078 |
|
# else |
1079 |
|
printf ("%ld:\tend of pattern.\n", (long int) (p - start)); |
1080 |
|
# endif |
1081 |
} |
} |
1082 |
|
|
1083 |
|
|
1084 |
void |
void |
1085 |
print_compiled_pattern (bufp) |
PREFIX(print_compiled_pattern) (struct re_pattern_buffer *bufp) |
|
struct re_pattern_buffer *bufp; |
|
1086 |
{ |
{ |
1087 |
unsigned char *buffer = bufp->buffer; |
UCHAR_T *buffer = (UCHAR_T*) bufp->buffer; |
1088 |
|
|
1089 |
print_partial_compiled_pattern (buffer, buffer + bufp->used); |
PREFIX(print_partial_compiled_pattern) (buffer, buffer |
1090 |
printf ("%d bytes used/%d bytes allocated.\n", bufp->used, bufp->allocated); |
+ bufp->used / sizeof(UCHAR_T)); |
1091 |
|
printf ("%ld bytes used/%ld bytes allocated.\n", |
1092 |
|
bufp->used, bufp->allocated); |
1093 |
|
|
1094 |
if (bufp->fastmap_accurate && bufp->fastmap) |
if (bufp->fastmap_accurate && bufp->fastmap) |
1095 |
{ |
{ |
1097 |
print_fastmap (bufp->fastmap); |
print_fastmap (bufp->fastmap); |
1098 |
} |
} |
1099 |
|
|
1100 |
printf ("re_nsub: %d\t", bufp->re_nsub); |
# ifdef _LIBC |
1101 |
|
printf ("re_nsub: %Zd\t", bufp->re_nsub); |
1102 |
|
# else |
1103 |
|
printf ("re_nsub: %ld\t", (long int) bufp->re_nsub); |
1104 |
|
# endif |
1105 |
printf ("regs_alloc: %d\t", bufp->regs_allocated); |
printf ("regs_alloc: %d\t", bufp->regs_allocated); |
1106 |
printf ("can_be_null: %d\t", bufp->can_be_null); |
printf ("can_be_null: %d\t", bufp->can_be_null); |
1107 |
printf ("newline_anchor: %d\n", bufp->newline_anchor); |
printf ("newline_anchor: %d\n", bufp->newline_anchor); |
1108 |
printf ("no_sub: %d\t", bufp->no_sub); |
printf ("no_sub: %d\t", bufp->no_sub); |
1109 |
printf ("not_bol: %d\t", bufp->not_bol); |
printf ("not_bol: %d\t", bufp->not_bol); |
1110 |
printf ("not_eol: %d\t", bufp->not_eol); |
printf ("not_eol: %d\t", bufp->not_eol); |
1111 |
printf ("syntax: %d\n", bufp->syntax); |
printf ("syntax: %lx\n", bufp->syntax); |
1112 |
/* Perhaps we should print the translate table? */ |
/* Perhaps we should print the translate table? */ |
1113 |
} |
} |
1114 |
|
|
1115 |
|
|
1116 |
void |
void |
1117 |
print_double_string (where, string1, size1, string2, size2) |
PREFIX(print_double_string) (const CHAR_T *where, |
1118 |
const char *where; |
const CHAR_T *string1, |
1119 |
const char *string1; |
const CHAR_T *string2, |
1120 |
const char *string2; |
int size1, |
1121 |
int size1; |
int size2) |
|
int size2; |
|
1122 |
{ |
{ |
1123 |
unsigned this_char; |
int this_char; |
1124 |
|
|
1125 |
if (where == NULL) |
if (where == NULL) |
1126 |
printf ("(null)"); |
printf ("(null)"); |
1127 |
else |
else |
1128 |
{ |
{ |
1129 |
|
int cnt; |
1130 |
|
|
1131 |
if (FIRST_STRING_P (where)) |
if (FIRST_STRING_P (where)) |
1132 |
{ |
{ |
1133 |
for (this_char = where - string1; this_char < size1; this_char++) |
for (this_char = where - string1; this_char < size1; this_char++) |
1134 |
printchar (string1[this_char]); |
PUT_CHAR (string1[this_char]); |
1135 |
|
|
1136 |
where = string2; |
where = string2; |
1137 |
} |
} |
1138 |
|
|
1139 |
|
cnt = 0; |
1140 |
for (this_char = where - string2; this_char < size2; this_char++) |
for (this_char = where - string2; this_char < size2; this_char++) |
1141 |
printchar (string2[this_char]); |
{ |
1142 |
|
PUT_CHAR (string2[this_char]); |
1143 |
|
if (++cnt > 100) |
1144 |
|
{ |
1145 |
|
fputs ("...", stdout); |
1146 |
|
break; |
1147 |
|
} |
1148 |
|
} |
1149 |
} |
} |
1150 |
} |
} |
1151 |
|
|
1152 |
#else /* not DEBUG */ |
# ifndef DEFINED_ONCE |
1153 |
|
void |
1154 |
|
printchar (c) |
1155 |
|
int c; |
1156 |
|
{ |
1157 |
|
putc (c, stderr); |
1158 |
|
} |
1159 |
|
# endif |
1160 |
|
|
1161 |
#undef assert |
# else /* not DEBUG */ |
|
#define assert(e) |
|
1162 |
|
|
1163 |
#define DEBUG_STATEMENT(e) |
# ifndef DEFINED_ONCE |
1164 |
#define DEBUG_PRINT1(x) |
# undef assert |
1165 |
#define DEBUG_PRINT2(x1, x2) |
# define assert(e) |
1166 |
#define DEBUG_PRINT3(x1, x2, x3) |
|
1167 |
#define DEBUG_PRINT4(x1, x2, x3, x4) |
# define DEBUG_STATEMENT(e) |
1168 |
#define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) |
# define DEBUG_PRINT1(x) |
1169 |
#define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) |
# define DEBUG_PRINT2(x1, x2) |
1170 |
|
# define DEBUG_PRINT3(x1, x2, x3) |
1171 |
|
# define DEBUG_PRINT4(x1, x2, x3, x4) |
1172 |
|
# endif /* not DEFINED_ONCE */ |
1173 |
|
# define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) |
1174 |
|
# define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2) |
1175 |
|
|
1176 |
|
# endif /* not DEBUG */ |
1177 |
|
|
|
#endif /* not DEBUG */ |
|
1178 |
|
|
1179 |
|
|
1180 |
|
# ifdef WCHAR |
1181 |
|
/* This convert a multibyte string to a wide character string. |
1182 |
|
And write their correspondances to offset_buffer(see below) |
1183 |
|
and write whether each wchar_t is binary data to is_binary. |
1184 |
|
This assume invalid multibyte sequences as binary data. |
1185 |
|
We assume offset_buffer and is_binary is already allocated |
1186 |
|
enough space. */ |
1187 |
|
|
1188 |
|
static size_t |
1189 |
|
convert_mbs_to_wcs (CHAR_T *dest, |
1190 |
|
const unsigned char* src, |
1191 |
|
|
1192 |
|
/* The length of multibyte string. */ |
1193 |
|
size_t len, |
1194 |
|
|
1195 |
|
/* Correspondences between src(char string) and |
1196 |
|
dest(wchar_t string) for optimization. E.g.: |
1197 |
|
src = "xxxyzz" |
1198 |
|
dest = {'X', 'Y', 'Z'} |
1199 |
|
(each "xxx", "y" and "zz" represent one |
1200 |
|
multibyte character corresponding to 'X', |
1201 |
|
'Y' and 'Z'.) |
1202 |
|
offset_buffer = {0, 0+3("xxx"), 0+3+1("y"), |
1203 |
|
0+3+1+2("zz")} |
1204 |
|
= {0, 3, 4, 6} */ |
1205 |
|
int *offset_buffer, |
1206 |
|
|
1207 |
|
char *is_binary) |
1208 |
|
{ |
1209 |
|
wchar_t *pdest = dest; |
1210 |
|
const unsigned char *psrc = src; |
1211 |
|
size_t wc_count = 0; |
1212 |
|
|
1213 |
|
mbstate_t mbs; |
1214 |
|
int i, consumed; |
1215 |
|
size_t mb_remain = len; |
1216 |
|
size_t mb_count = 0; |
1217 |
|
|
1218 |
|
/* Initialize the conversion state. */ |
1219 |
|
memset (&mbs, 0, sizeof (mbstate_t)); |
1220 |
|
|
1221 |
|
offset_buffer[0] = 0; |
1222 |
|
for( ; mb_remain > 0 ; ++wc_count, ++pdest, mb_remain -= consumed, |
1223 |
|
psrc += consumed) |
1224 |
|
{ |
1225 |
|
consumed = mbrtowc (pdest, psrc, mb_remain, &mbs); |
1226 |
|
|
1227 |
|
if (consumed <= 0) |
1228 |
|
/* failed to convert. maybe src contains binary data. |
1229 |
|
So we consume 1 byte manualy. */ |
1230 |
|
{ |
1231 |
|
*pdest = *psrc; |
1232 |
|
consumed = 1; |
1233 |
|
is_binary[wc_count] = TRUE; |
1234 |
|
} |
1235 |
|
else |
1236 |
|
is_binary[wc_count] = FALSE; |
1237 |
|
/* In sjis encoding, we use yen sign as escape character in |
1238 |
|
place of reverse solidus. So we convert 0x5c(yen sign in |
1239 |
|
sjis) to not 0xa5(yen sign in UCS2) but 0x5c(reverse |
1240 |
|
solidus in UCS2). */ |
1241 |
|
if (consumed == 1 && (int) *psrc == 0x5c && (int) *pdest == 0xa5) |
1242 |
|
*pdest = (wchar_t) *psrc; |
1243 |
|
|
1244 |
|
offset_buffer[wc_count + 1] = mb_count += consumed; |
1245 |
|
} |
1246 |
|
|
1247 |
|
/* Fill remain of the buffer with sentinel. */ |
1248 |
|
for (i = wc_count + 1 ; i <= len ; i++) |
1249 |
|
offset_buffer[i] = mb_count + 1; |
1250 |
|
|
1251 |
|
return wc_count; |
1252 |
|
} |
1253 |
|
|
1254 |
|
# endif /* WCHAR */ |
1255 |
|
|
1256 |
|
#else /* not INSIDE_RECURSION */ |
1257 |
|
|
1258 |
/* Set by `re_set_syntax' to the current regexp syntax to recognize. Can |
/* Set by `re_set_syntax' to the current regexp syntax to recognize. Can |
1259 |
also be assigned to arbitrarily: each pattern buffer stores its own |
also be assigned to arbitrarily: each pattern buffer stores its own |
1260 |
syntax, so it can be changed between regex compilations. */ |
syntax, so it can be changed between regex compilations. */ |
1261 |
reg_syntax_t re_syntax_options = RE_SYNTAX_EMACS; |
/* This has no initializer because initialized variables in Emacs |
1262 |
|
become read-only after dumping. */ |
1263 |
|
reg_syntax_t re_syntax_options; |
1264 |
|
|
1265 |
|
|
1266 |
/* Specify the precise syntax of regexps for compilation. This provides |
/* Specify the precise syntax of regexps for compilation. This provides |
1271 |
defined in regex.h. We return the old syntax. */ |
defined in regex.h. We return the old syntax. */ |
1272 |
|
|
1273 |
reg_syntax_t |
reg_syntax_t |
1274 |
re_set_syntax (syntax) |
re_set_syntax (reg_syntax_t syntax) |
|
reg_syntax_t syntax; |
|
1275 |
{ |
{ |
1276 |
reg_syntax_t ret = re_syntax_options; |
reg_syntax_t ret = re_syntax_options; |
1277 |
|
|
1278 |
re_syntax_options = syntax; |
re_syntax_options = syntax; |
1279 |
|
# ifdef DEBUG |
1280 |
|
if (syntax & RE_DEBUG) |
1281 |
|
debug = 1; |
1282 |
|
else if (debug) /* was on but now is not */ |
1283 |
|
debug = 0; |
1284 |
|
# endif /* DEBUG */ |
1285 |
return ret; |
return ret; |
1286 |
} |
} |
1287 |
|
# ifdef _LIBC |
1288 |
|
weak_alias (__re_set_syntax, re_set_syntax) |
1289 |
|
# endif |
1290 |
|
|
1291 |
/* This table gives an error message for each of the error codes listed |
/* This table gives an error message for each of the error codes listed |
1292 |
in regex.h. Obviously the order here has to be same as there. */ |
in regex.h. Obviously the order here has to be same as there. |
1293 |
|
POSIX doesn't require that we do anything for REG_NOERROR, |
1294 |
|
but why not be nice? */ |
1295 |
|
|
1296 |
static const char *re_error_msg[] = |
static const char re_error_msgid[] = |
1297 |
{ NULL, /* REG_NOERROR */ |
{ |
1298 |
"No match", /* REG_NOMATCH */ |
# define REG_NOERROR_IDX 0 |
1299 |
"Invalid regular expression", /* REG_BADPAT */ |
gettext_noop ("Success") /* REG_NOERROR */ |
1300 |
"Invalid collation character", /* REG_ECOLLATE */ |
"\0" |
1301 |
"Invalid character class name", /* REG_ECTYPE */ |
# define REG_NOMATCH_IDX (REG_NOERROR_IDX + sizeof "Success") |
1302 |
"Trailing backslash", /* REG_EESCAPE */ |
gettext_noop ("No match") /* REG_NOMATCH */ |
1303 |
"Invalid back reference", /* REG_ESUBREG */ |
"\0" |
1304 |
"Unmatched [ or [^", /* REG_EBRACK */ |
# define REG_BADPAT_IDX (REG_NOMATCH_IDX + sizeof "No match") |
1305 |
"Unmatched ( or \\(", /* REG_EPAREN */ |
gettext_noop ("Invalid regular expression") /* REG_BADPAT */ |
1306 |
"Unmatched \\{", /* REG_EBRACE */ |
"\0" |
1307 |
"Invalid content of \\{\\}", /* REG_BADBR */ |
# define REG_ECOLLATE_IDX (REG_BADPAT_IDX + sizeof "Invalid regular expression") |
1308 |
"Invalid range end", /* REG_ERANGE */ |
gettext_noop ("Invalid collation character") /* REG_ECOLLATE */ |
1309 |
"Memory exhausted", /* REG_ESPACE */ |
"\0" |
1310 |
"Invalid preceding regular expression", /* REG_BADRPT */ |
# define REG_ECTYPE_IDX (REG_ECOLLATE_IDX + sizeof "Invalid collation character") |
1311 |
"Premature end of regular expression", /* REG_EEND */ |
gettext_noop ("Invalid character class name") /* REG_ECTYPE */ |
1312 |
"Regular expression too big", /* REG_ESIZE */ |
"\0" |
1313 |
"Unmatched ) or \\)", /* REG_ERPAREN */ |
# define REG_EESCAPE_IDX (REG_ECTYPE_IDX + sizeof "Invalid character class name") |
1314 |
|
gettext_noop ("Trailing backslash") /* REG_EESCAPE */ |
1315 |
|
"\0" |
1316 |
|
# define REG_ESUBREG_IDX (REG_EESCAPE_IDX + sizeof "Trailing backslash") |
1317 |
|
gettext_noop ("Invalid back reference") /* REG_ESUBREG */ |
1318 |
|
"\0" |
1319 |
|
# define REG_EBRACK_IDX (REG_ESUBREG_IDX + sizeof "Invalid back reference") |
1320 |
|
gettext_noop ("Unmatched [ or [^") /* REG_EBRACK */ |
1321 |
|
"\0" |
1322 |
|
# define REG_EPAREN_IDX (REG_EBRACK_IDX + sizeof "Unmatched [ or [^") |
1323 |
|
gettext_noop ("Unmatched ( or \\(") /* REG_EPAREN */ |
1324 |
|
"\0" |
1325 |
|
# define REG_EBRACE_IDX (REG_EPAREN_IDX + sizeof "Unmatched ( or \\(") |
1326 |
|
gettext_noop ("Unmatched \\{") /* REG_EBRACE */ |
1327 |
|
"\0" |
1328 |
|
# define REG_BADBR_IDX (REG_EBRACE_IDX + sizeof "Unmatched \\{") |
1329 |
|
gettext_noop ("Invalid content of \\{\\}") /* REG_BADBR */ |
1330 |
|
"\0" |
1331 |
|
# define REG_ERANGE_IDX (REG_BADBR_IDX + sizeof "Invalid content of \\{\\}") |
1332 |
|
gettext_noop ("Invalid range end") /* REG_ERANGE */ |
1333 |
|
"\0" |
1334 |
|
# define REG_ESPACE_IDX (REG_ERANGE_IDX + sizeof "Invalid range end") |
1335 |
|
gettext_noop ("Memory exhausted") /* REG_ESPACE */ |
1336 |
|
"\0" |
1337 |
|
# define REG_BADRPT_IDX (REG_ESPACE_IDX + sizeof "Memory exhausted") |
1338 |
|
gettext_noop ("Invalid preceding regular expression") /* REG_BADRPT */ |
1339 |
|
"\0" |
1340 |
|
# define REG_EEND_IDX (REG_BADRPT_IDX + sizeof "Invalid preceding regular expression") |
1341 |
|
gettext_noop ("Premature end of regular expression") /* REG_EEND */ |
1342 |
|
"\0" |
1343 |
|
# define REG_ESIZE_IDX (REG_EEND_IDX + sizeof "Premature end of regular expression") |
1344 |
|
gettext_noop ("Regular expression too big") /* REG_ESIZE */ |
1345 |
|
"\0" |
1346 |
|
# define REG_ERPAREN_IDX (REG_ESIZE_IDX + sizeof "Regular expression too big") |
1347 |
|
gettext_noop ("Unmatched ) or \\)") /* REG_ERPAREN */ |
1348 |
|
}; |
1349 |
|
|
1350 |
|
static const size_t re_error_msgid_idx[] = |
1351 |
|
{ |
1352 |
|
REG_NOERROR_IDX, |
1353 |
|
REG_NOMATCH_IDX, |
1354 |
|
REG_BADPAT_IDX, |
1355 |
|
REG_ECOLLATE_IDX, |
1356 |
|
REG_ECTYPE_IDX, |
1357 |
|
REG_EESCAPE_IDX, |
1358 |
|
REG_ESUBREG_IDX, |
1359 |
|
REG_EBRACK_IDX, |
1360 |
|
REG_EPAREN_IDX, |
1361 |
|
REG_EBRACE_IDX, |
1362 |
|
REG_BADBR_IDX, |
1363 |
|
REG_ERANGE_IDX, |
1364 |
|
REG_ESPACE_IDX, |
1365 |
|
REG_BADRPT_IDX, |
1366 |
|
REG_EEND_IDX, |
1367 |
|
REG_ESIZE_IDX, |
1368 |
|
REG_ERPAREN_IDX |
1369 |
}; |
}; |
1370 |
|
|
1371 |
|
#endif /* INSIDE_RECURSION */ |
1372 |
|
|
1373 |
|
#ifndef DEFINED_ONCE |
1374 |
/* Avoiding alloca during matching, to placate r_alloc. */ |
/* Avoiding alloca during matching, to placate r_alloc. */ |
1375 |
|
|
1376 |
/* Define MATCH_MAY_ALLOCATE unless we need to make sure that the |
/* Define MATCH_MAY_ALLOCATE unless we need to make sure that the |
1381 |
ralloc heap) shift the data out from underneath the regexp |
ralloc heap) shift the data out from underneath the regexp |
1382 |
routines. |
routines. |
1383 |
|
|
1384 |
Here's another reason to avoid allocation: Emacs |
Here's another reason to avoid allocation: Emacs |
1385 |
processes input from X in a signal handler; processing X input may |
processes input from X in a signal handler; processing X input may |
1386 |
call malloc; if input arrives while a matching routine is calling |
call malloc; if input arrives while a matching routine is calling |
1387 |
malloc, then we're scrod. But Emacs can't just block input while |
malloc, then we're scrod. But Emacs can't just block input while |
1391 |
faith that they will not malloc. */ |
faith that they will not malloc. */ |
1392 |
|
|
1393 |
/* Normally, this is fine. */ |
/* Normally, this is fine. */ |
1394 |
#define MATCH_MAY_ALLOCATE |
# define MATCH_MAY_ALLOCATE |
1395 |
|
|
1396 |
/* The match routines may not allocate if (1) they would do it with malloc |
/* When using GNU C, we are not REALLY using the C alloca, no matter |
1397 |
and (2) it's not safe for them to use malloc. */ |
what config.h may say. So don't take precautions for it. */ |
1398 |
#if (defined (C_ALLOCA) || defined (REGEX_MALLOC)) && (defined (emacs) || defined (REL_ALLOC)) |
# ifdef __GNUC__ |
1399 |
#undef MATCH_MAY_ALLOCATE |
# undef C_ALLOCA |
1400 |
#endif |
# endif |
1401 |
|
|
1402 |
|
/* The match routines may not allocate if (1) they would do it with malloc |
1403 |
|
and (2) it's not safe for them to use malloc. |
1404 |
|
Note that if REL_ALLOC is defined, matching would not use malloc for the |
1405 |
|
failure stack, but we would still use it for the register vectors; |
1406 |
|
so REL_ALLOC should not affect this. */ |
1407 |
|
# if (defined C_ALLOCA || defined REGEX_MALLOC) && defined emacs |
1408 |
|
# undef MATCH_MAY_ALLOCATE |
1409 |
|
# endif |
1410 |
|
#endif /* not DEFINED_ONCE */ |
1411 |
|
|
1412 |
|
#ifdef INSIDE_RECURSION |
1413 |
/* Failure stack declarations and macros; both re_compile_fastmap and |
/* Failure stack declarations and macros; both re_compile_fastmap and |
1414 |
re_match_2 use a failure stack. These have to be macros because of |
re_match_2 use a failure stack. These have to be macros because of |
1415 |
REGEX_ALLOCATE. */ |
REGEX_ALLOCATE_STACK. */ |
1416 |
|
|
1417 |
|
|
1418 |
/* Number of failure points for which to initially allocate space |
/* Number of failure points for which to initially allocate space |
1419 |
when matching. If this number is exceeded, we allocate more |
when matching. If this number is exceeded, we allocate more |
1420 |
space, so it is not a hard limit. */ |
space, so it is not a hard limit. */ |
1421 |
#ifndef INIT_FAILURE_ALLOC |
# ifndef INIT_FAILURE_ALLOC |
1422 |
#define INIT_FAILURE_ALLOC 5 |
# define INIT_FAILURE_ALLOC 5 |
1423 |
#endif |
# endif |
1424 |
|
|
1425 |
/* Roughly the maximum number of failure points on the stack. Would be |
/* Roughly the maximum number of failure points on the stack. Would be |
1426 |
exactly that if always used MAX_FAILURE_SPACE each time we failed. |
exactly that if always used MAX_FAILURE_ITEMS items each time we failed. |
1427 |
This is a variable only so users of regex can assign to it; we never |
This is a variable only so users of regex can assign to it; we never |
1428 |
change it ourselves. */ |
change it ourselves. */ |
1429 |
|
|
1430 |
|
# ifdef INT_IS_16BIT |
1431 |
|
|
1432 |
|
# ifndef DEFINED_ONCE |
1433 |
|
# if defined MATCH_MAY_ALLOCATE |
1434 |
|
/* 4400 was enough to cause a crash on Alpha OSF/1, |
1435 |
|
whose default stack limit is 2mb. */ |
1436 |
|
long int re_max_failures = 4000; |
1437 |
|
# else |
1438 |
|
long int re_max_failures = 2000; |
1439 |
|
# endif |
1440 |
|
# endif |
1441 |
|
|
1442 |
|
union PREFIX(fail_stack_elt) |
1443 |
|
{ |
1444 |
|
UCHAR_T *pointer; |
1445 |
|
long int integer; |
1446 |
|
}; |
1447 |
|
|
1448 |
|
typedef union PREFIX(fail_stack_elt) PREFIX(fail_stack_elt_t); |
1449 |
|
|
1450 |
|
typedef struct |
1451 |
|
{ |
1452 |
|
PREFIX(fail_stack_elt_t) *stack; |
1453 |
|
unsigned long int size; |
1454 |
|
unsigned long int avail; /* Offset of next open position. */ |
1455 |
|
} PREFIX(fail_stack_type); |
1456 |
|
|
1457 |
|
# else /* not INT_IS_16BIT */ |
1458 |
|
|
1459 |
|
# ifndef DEFINED_ONCE |
1460 |
|
# if defined MATCH_MAY_ALLOCATE |
1461 |
|
/* 4400 was enough to cause a crash on Alpha OSF/1, |
1462 |
|
whose default stack limit is 2mb. */ |
1463 |
|
int re_max_failures = 4000; |
1464 |
|
# else |
1465 |
int re_max_failures = 2000; |
int re_max_failures = 2000; |
1466 |
|
# endif |
1467 |
|
# endif |
1468 |
|
|
1469 |
typedef unsigned char *fail_stack_elt_t; |
union PREFIX(fail_stack_elt) |
1470 |
|
{ |
1471 |
|
UCHAR_T *pointer; |
1472 |
|
int integer; |
1473 |
|
}; |
1474 |
|
|
1475 |
|
typedef union PREFIX(fail_stack_elt) PREFIX(fail_stack_elt_t); |
1476 |
|
|
1477 |
typedef struct |
typedef struct |
1478 |
{ |
{ |
1479 |
fail_stack_elt_t *stack; |
PREFIX(fail_stack_elt_t) *stack; |
1480 |
unsigned size; |
unsigned size; |
1481 |
unsigned avail; /* Offset of next open position. */ |
unsigned avail; /* Offset of next open position. */ |
1482 |
} fail_stack_type; |
} PREFIX(fail_stack_type); |
1483 |
|
|
1484 |
#define FAIL_STACK_EMPTY() (fail_stack.avail == 0) |
# endif /* INT_IS_16BIT */ |
|
#define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0) |
|
|
#define FAIL_STACK_FULL() (fail_stack.avail == fail_stack.size) |
|
|
#define FAIL_STACK_TOP() (fail_stack.stack[fail_stack.avail]) |
|
1485 |
|
|
1486 |
|
# ifndef DEFINED_ONCE |
1487 |
|
# define FAIL_STACK_EMPTY() (fail_stack.avail == 0) |
1488 |
|
# define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0) |
1489 |
|
# define FAIL_STACK_FULL() (fail_stack.avail == fail_stack.size) |
1490 |
|
# endif |
1491 |
|
|
|
/* Initialize `fail_stack'. Do `return -2' if the alloc fails. */ |
|
1492 |
|
|
1493 |
#ifdef MATCH_MAY_ALLOCATE |
/* Define macros to initialize and free the failure stack. |
1494 |
#define INIT_FAIL_STACK() \ |
Do `return -2' if the alloc fails. */ |
1495 |
|
|
1496 |
|
# ifdef MATCH_MAY_ALLOCATE |
1497 |
|
# define INIT_FAIL_STACK() \ |
1498 |
do { \ |
do { \ |
1499 |
fail_stack.stack = (fail_stack_elt_t *) \ |
fail_stack.stack = (PREFIX(fail_stack_elt_t) *) \ |
1500 |
REGEX_ALLOCATE (INIT_FAILURE_ALLOC * sizeof (fail_stack_elt_t)); \ |
REGEX_ALLOCATE_STACK (INIT_FAILURE_ALLOC * sizeof (PREFIX(fail_stack_elt_t))); \ |
1501 |
\ |
\ |
1502 |
if (fail_stack.stack == NULL) \ |
if (fail_stack.stack == NULL) \ |
1503 |
return -2; \ |
return -2; \ |
1504 |
\ |
\ |
1505 |
fail_stack.size = INIT_FAILURE_ALLOC; \ |
fail_stack.size = INIT_FAILURE_ALLOC; \ |
1506 |
fail_stack.avail = 0; \ |
fail_stack.avail = 0; \ |
1507 |
} while (0) |
} while (0) |
1508 |
#else |
|
1509 |
#define INIT_FAIL_STACK() \ |
# define RESET_FAIL_STACK() REGEX_FREE_STACK (fail_stack.stack) |
1510 |
|
# else |
1511 |
|
# define INIT_FAIL_STACK() \ |
1512 |
do { \ |
do { \ |
1513 |
fail_stack.avail = 0; \ |
fail_stack.avail = 0; \ |
1514 |
} while (0) |
} while (0) |
1515 |
#endif |
|
1516 |
|
# define RESET_FAIL_STACK() |
1517 |
|
# endif |
1518 |
|
|
1519 |
|
|
1520 |
/* Double the size of FAIL_STACK, up to approximately `re_max_failures' items. |
/* Double the size of FAIL_STACK, up to approximately `re_max_failures' items. |
1521 |
|
|
1522 |
Return 1 if succeeds, and 0 if either ran out of memory |
Return 1 if succeeds, and 0 if either ran out of memory |
1523 |
allocating space for it or it was already too large. |
allocating space for it or it was already too large. |
1524 |
|
|
1525 |
REGEX_REALLOCATE requires `destination' be declared. */ |
REGEX_REALLOCATE_STACK requires `destination' be declared. */ |
1526 |
|
|
1527 |
#define DOUBLE_FAIL_STACK(fail_stack) \ |
# define DOUBLE_FAIL_STACK(fail_stack) \ |
1528 |
((fail_stack).size > re_max_failures * MAX_FAILURE_ITEMS \ |
((fail_stack).size > (unsigned) (re_max_failures * MAX_FAILURE_ITEMS) \ |
1529 |
? 0 \ |
? 0 \ |
1530 |
: ((fail_stack).stack = (fail_stack_elt_t *) \ |
: ((fail_stack).stack = (PREFIX(fail_stack_elt_t) *) \ |
1531 |
REGEX_REALLOCATE ((fail_stack).stack, \ |
REGEX_REALLOCATE_STACK ((fail_stack).stack, \ |
1532 |
(fail_stack).size * sizeof (fail_stack_elt_t), \ |
(fail_stack).size * sizeof (PREFIX(fail_stack_elt_t)), \ |
1533 |
((fail_stack).size << 1) * sizeof (fail_stack_elt_t)), \ |
((fail_stack).size << 1) * sizeof (PREFIX(fail_stack_elt_t))),\ |
1534 |
\ |
\ |
1535 |
(fail_stack).stack == NULL \ |
(fail_stack).stack == NULL \ |
1536 |
? 0 \ |
? 0 \ |
1538 |
1))) |
1))) |
1539 |
|
|
1540 |
|
|
1541 |
/* Push PATTERN_OP on FAIL_STACK. |
/* Push pointer POINTER on FAIL_STACK. |
|
|
|
1542 |
Return 1 if was able to do so and 0 if ran out of memory allocating |
Return 1 if was able to do so and 0 if ran out of memory allocating |
1543 |
space to do so. */ |
space to do so. */ |
1544 |
#define PUSH_PATTERN_OP(pattern_op, fail_stack) \ |
# define PUSH_PATTERN_OP(POINTER, FAIL_STACK) \ |
1545 |
((FAIL_STACK_FULL () \ |
((FAIL_STACK_FULL () \ |
1546 |
&& !DOUBLE_FAIL_STACK (fail_stack)) \ |
&& !DOUBLE_FAIL_STACK (FAIL_STACK)) \ |
1547 |
? 0 \ |
? 0 \ |
1548 |
: ((fail_stack).stack[(fail_stack).avail++] = pattern_op, \ |
: ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER, \ |
1549 |
1)) |
1)) |
1550 |
|
|
1551 |
|
/* Push a pointer value onto the failure stack. |
1552 |
|
Assumes the variable `fail_stack'. Probably should only |
1553 |
|
be called from within `PUSH_FAILURE_POINT'. */ |
1554 |
|
# define PUSH_FAILURE_POINTER(item) \ |
1555 |
|
fail_stack.stack[fail_stack.avail++].pointer = (UCHAR_T *) (item) |
1556 |
|
|
1557 |
/* This pushes an item onto the failure stack. Must be a four-byte |
/* This pushes an integer-valued item onto the failure stack. |
1558 |
value. Assumes the variable `fail_stack'. Probably should only |
Assumes the variable `fail_stack'. Probably should only |
1559 |
be called from within `PUSH_FAILURE_POINT'. */ |
be called from within `PUSH_FAILURE_POINT'. */ |
1560 |
#define PUSH_FAILURE_ITEM(item) \ |
# define PUSH_FAILURE_INT(item) \ |
1561 |
fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) item |
fail_stack.stack[fail_stack.avail++].integer = (item) |
1562 |
|
|
1563 |
/* The complement operation. Assumes `fail_stack' is nonempty. */ |
/* Push a fail_stack_elt_t value onto the failure stack. |
1564 |
#define POP_FAILURE_ITEM() fail_stack.stack[--fail_stack.avail] |
Assumes the variable `fail_stack'. Probably should only |
1565 |
|
be called from within `PUSH_FAILURE_POINT'. */ |
1566 |
|
# define PUSH_FAILURE_ELT(item) \ |
1567 |
|
fail_stack.stack[fail_stack.avail++] = (item) |
1568 |
|
|
1569 |
|
/* These three POP... operations complement the three PUSH... operations. |
1570 |
|
All assume that `fail_stack' is nonempty. */ |
1571 |
|
# define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer |
1572 |
|
# define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer |
1573 |
|
# define POP_FAILURE_ELT() fail_stack.stack[--fail_stack.avail] |
1574 |
|
|
1575 |
/* Used to omit pushing failure point id's when we're not debugging. */ |
/* Used to omit pushing failure point id's when we're not debugging. */ |
1576 |
#ifdef DEBUG |
# ifdef DEBUG |
1577 |
#define DEBUG_PUSH PUSH_FAILURE_ITEM |
# define DEBUG_PUSH PUSH_FAILURE_INT |
1578 |
#define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_ITEM () |
# define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_INT () |
1579 |
#else |
# else |
1580 |
#define DEBUG_PUSH(item) |
# define DEBUG_PUSH(item) |
1581 |
#define DEBUG_POP(item_addr) |
# define DEBUG_POP(item_addr) |
1582 |
#endif |
# endif |
1583 |
|
|
1584 |
|
|
1585 |
/* Push the information about the state we will need |
/* Push the information about the state we will need |
1586 |
if we ever fail back to it. |
if we ever fail back to it. |
1587 |
|
|
1588 |
Requires variables fail_stack, regstart, regend, reg_info, and |
Requires variables fail_stack, regstart, regend, reg_info, and |
1589 |
num_regs be declared. DOUBLE_FAIL_STACK requires `destination' be |
num_regs_pushed be declared. DOUBLE_FAIL_STACK requires `destination' |
1590 |
declared. |
be declared. |
1591 |
|
|
1592 |
Does `return FAILURE_CODE' if runs out of memory. */ |
Does `return FAILURE_CODE' if runs out of memory. */ |
1593 |
|
|
1594 |
#define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code) \ |
# define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code) \ |
1595 |
do { \ |
do { \ |
1596 |
char *destination; \ |
char *destination; \ |
1597 |
/* Must be int, so when we don't save any registers, the arithmetic \ |
/* Must be int, so when we don't save any registers, the arithmetic \ |
1598 |
of 0 + -1 isn't done as unsigned. */ \ |
of 0 + -1 isn't done as unsigned. */ \ |
1599 |
int this_reg; \ |
/* Can't be int, since there is not a shred of a guarantee that int \ |
1600 |
|
is wide enough to hold a value of something to which pointer can \ |
1601 |
|
be assigned */ \ |
1602 |
|
active_reg_t this_reg; \ |
1603 |
\ |
\ |
1604 |
DEBUG_STATEMENT (failure_id++); \ |
DEBUG_STATEMENT (failure_id++); \ |
1605 |
DEBUG_STATEMENT (nfailure_points_pushed++); \ |
DEBUG_STATEMENT (nfailure_points_pushed++); \ |
1607 |
DEBUG_PRINT2 (" Before push, next avail: %d\n", (fail_stack).avail);\ |
DEBUG_PRINT2 (" Before push, next avail: %d\n", (fail_stack).avail);\ |
1608 |
DEBUG_PRINT2 (" size: %d\n", (fail_stack).size);\ |
DEBUG_PRINT2 (" size: %d\n", (fail_stack).size);\ |
1609 |
\ |
\ |
1610 |
DEBUG_PRINT2 (" slots needed: %d\n", NUM_FAILURE_ITEMS); \ |
DEBUG_PRINT2 (" slots needed: %ld\n", NUM_FAILURE_ITEMS); \ |
1611 |
DEBUG_PRINT2 (" available: %d\n", REMAINING_AVAIL_SLOTS); \ |
DEBUG_PRINT2 (" available: %d\n", REMAINING_AVAIL_SLOTS); \ |
1612 |
\ |
\ |
1613 |
/* Ensure we have enough space allocated for what we will push. */ \ |
/* Ensure we have enough space allocated for what we will push. */ \ |
1614 |
while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS) \ |
while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS) \ |
1615 |
{ \ |
{ \ |
1616 |
if (!DOUBLE_FAIL_STACK (fail_stack)) \ |
if (!DOUBLE_FAIL_STACK (fail_stack)) \ |
1617 |
return failure_code; \ |
return failure_code; \ |
1618 |
\ |
\ |
1619 |
DEBUG_PRINT2 ("\n Doubled stack; size now: %d\n", \ |
DEBUG_PRINT2 ("\n Doubled stack; size now: %d\n", \ |
1624 |
/* Push the info, starting with the registers. */ \ |
/* Push the info, starting with the registers. */ \ |
1625 |
DEBUG_PRINT1 ("\n"); \ |
DEBUG_PRINT1 ("\n"); \ |
1626 |
\ |
\ |
1627 |
for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; \ |
if (1) \ |
1628 |
this_reg++) \ |
for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; \ |
1629 |
{ \ |
this_reg++) \ |
1630 |
DEBUG_PRINT2 (" Pushing reg: %d\n", this_reg); \ |
{ \ |
1631 |
DEBUG_STATEMENT (num_regs_pushed++); \ |
DEBUG_PRINT2 (" Pushing reg: %lu\n", this_reg); \ |
1632 |
|
DEBUG_STATEMENT (num_regs_pushed++); \ |
1633 |
\ |
\ |
1634 |
DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \ |
DEBUG_PRINT2 (" start: %p\n", regstart[this_reg]); \ |
1635 |
PUSH_FAILURE_ITEM (regstart[this_reg]); \ |
PUSH_FAILURE_POINTER (regstart[this_reg]); \ |
|
\ |
|
|
DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \ |
|
|
PUSH_FAILURE_ITEM (regend[this_reg]); \ |
|
1636 |
\ |
\ |
1637 |
DEBUG_PRINT2 (" info: 0x%x\n ", reg_info[this_reg]); \ |
DEBUG_PRINT2 (" end: %p\n", regend[this_reg]); \ |
1638 |
DEBUG_PRINT2 (" match_null=%d", \ |
PUSH_FAILURE_POINTER (regend[this_reg]); \ |
|
REG_MATCH_NULL_STRING_P (reg_info[this_reg])); \ |
|
|
DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg])); \ |
|
|
DEBUG_PRINT2 (" matched_something=%d", \ |
|
|
MATCHED_SOMETHING (reg_info[this_reg])); \ |
|
|
DEBUG_PRINT2 (" ever_matched=%d", \ |
|
|
EVER_MATCHED_SOMETHING (reg_info[this_reg])); \ |
|
|
DEBUG_PRINT1 ("\n"); \ |
|
|
PUSH_FAILURE_ITEM (reg_info[this_reg].word); \ |
|
|
} \ |
|
1639 |
\ |
\ |
1640 |
DEBUG_PRINT2 (" Pushing low active reg: %d\n", lowest_active_reg);\ |
DEBUG_PRINT2 (" info: %p\n ", \ |
1641 |
PUSH_FAILURE_ITEM (lowest_active_reg); \ |
reg_info[this_reg].word.pointer); \ |
1642 |
|
DEBUG_PRINT2 (" match_null=%d", \ |
1643 |
|
REG_MATCH_NULL_STRING_P (reg_info[this_reg])); \ |
1644 |
|
DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg])); \ |
1645 |
|
DEBUG_PRINT2 (" matched_something=%d", \ |
1646 |
|
MATCHED_SOMETHING (reg_info[this_reg])); \ |
1647 |
|
DEBUG_PRINT2 (" ever_matched=%d", \ |
1648 |
|
EVER_MATCHED_SOMETHING (reg_info[this_reg])); \ |
1649 |
|
DEBUG_PRINT1 ("\n"); \ |
1650 |
|
PUSH_FAILURE_ELT (reg_info[this_reg].word); \ |
1651 |
|
} \ |
1652 |
\ |
\ |
1653 |
DEBUG_PRINT2 (" Pushing high active reg: %d\n", highest_active_reg);\ |
DEBUG_PRINT2 (" Pushing low active reg: %ld\n", lowest_active_reg);\ |
1654 |
PUSH_FAILURE_ITEM (highest_active_reg); \ |
PUSH_FAILURE_INT (lowest_active_reg); \ |
1655 |
\ |
\ |
1656 |
DEBUG_PRINT2 (" Pushing pattern 0x%x: ", pattern_place); \ |
DEBUG_PRINT2 (" Pushing high active reg: %ld\n", highest_active_reg);\ |
1657 |
|
PUSH_FAILURE_INT (highest_active_reg); \ |
1658 |
|
\ |
1659 |
|
DEBUG_PRINT2 (" Pushing pattern %p:\n", pattern_place); \ |
1660 |
DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend); \ |
DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend); \ |
1661 |
PUSH_FAILURE_ITEM (pattern_place); \ |
PUSH_FAILURE_POINTER (pattern_place); \ |
1662 |
\ |
\ |
1663 |
DEBUG_PRINT2 (" Pushing string 0x%x: `", string_place); \ |
DEBUG_PRINT2 (" Pushing string %p: `", string_place); \ |
1664 |
DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2, \ |
DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2, \ |
1665 |
size2); \ |
size2); \ |
1666 |
DEBUG_PRINT1 ("'\n"); \ |
DEBUG_PRINT1 ("'\n"); \ |
1667 |
PUSH_FAILURE_ITEM (string_place); \ |
PUSH_FAILURE_POINTER (string_place); \ |
1668 |
\ |
\ |
1669 |
DEBUG_PRINT2 (" Pushing failure id: %u\n", failure_id); \ |
DEBUG_PRINT2 (" Pushing failure id: %u\n", failure_id); \ |
1670 |
DEBUG_PUSH (failure_id); \ |
DEBUG_PUSH (failure_id); \ |
1671 |
} while (0) |
} while (0) |
1672 |
|
|
1673 |
|
# ifndef DEFINED_ONCE |
1674 |
/* This is the number of items that are pushed and popped on the stack |
/* This is the number of items that are pushed and popped on the stack |
1675 |
for each register. */ |
for each register. */ |
1676 |
#define NUM_REG_ITEMS 3 |
# define NUM_REG_ITEMS 3 |
1677 |
|
|
1678 |
/* Individual items aside from the registers. */ |
/* Individual items aside from the registers. */ |
1679 |
#ifdef DEBUG |
# ifdef DEBUG |
1680 |
#define NUM_NONREG_ITEMS 5 /* Includes failure point id. */ |
# define NUM_NONREG_ITEMS 5 /* Includes failure point id. */ |
1681 |
#else |
# else |
1682 |
#define NUM_NONREG_ITEMS 4 |
# define NUM_NONREG_ITEMS 4 |
1683 |
#endif |
# endif |
1684 |
|
|
1685 |
/* We push at most this many items on the stack. */ |
/* We push at most this many items on the stack. */ |
1686 |
#define MAX_FAILURE_ITEMS ((num_regs - 1) * NUM_REG_ITEMS + NUM_NONREG_ITEMS) |
/* We used to use (num_regs - 1), which is the number of registers |
1687 |
|
this regexp will save; but that was changed to 5 |
1688 |
|
to avoid stack overflow for a regexp with lots of parens. */ |
1689 |
|
# define MAX_FAILURE_ITEMS (5 * NUM_REG_ITEMS + NUM_NONREG_ITEMS) |
1690 |
|
|
1691 |
/* We actually push this many items. */ |
/* We actually push this many items. */ |
1692 |
#define NUM_FAILURE_ITEMS \ |
# define NUM_FAILURE_ITEMS \ |
1693 |
((highest_active_reg - lowest_active_reg + 1) * NUM_REG_ITEMS \ |
(((0 \ |
1694 |
+ NUM_NONREG_ITEMS) |
? 0 : highest_active_reg - lowest_active_reg + 1) \ |
1695 |
|
* NUM_REG_ITEMS) \ |
1696 |
|
+ NUM_NONREG_ITEMS) |
1697 |
|
|
1698 |
/* How many items can still be added to the stack without overflowing it. */ |
/* How many items can still be added to the stack without overflowing it. */ |
1699 |
#define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail) |
# define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail) |
1700 |
|
# endif /* not DEFINED_ONCE */ |
1701 |
|
|
1702 |
|
|
1703 |
/* Pops what PUSH_FAIL_STACK pushes. |
/* Pops what PUSH_FAIL_STACK pushes. |
1708 |
LOW_REG, HIGH_REG -- the highest and lowest active registers. |
LOW_REG, HIGH_REG -- the highest and lowest active registers. |
1709 |
REGSTART, REGEND -- arrays of string positions. |
REGSTART, REGEND -- arrays of string positions. |
1710 |
REG_INFO -- array of information about each subexpression. |
REG_INFO -- array of information about each subexpression. |
1711 |
|
|
1712 |
Also assumes the variables `fail_stack' and (if debugging), `bufp', |
Also assumes the variables `fail_stack' and (if debugging), `bufp', |
1713 |
`pend', `string1', `size1', `string2', and `size2'. */ |
`pend', `string1', `size1', `string2', and `size2'. */ |
1714 |
|
# define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\ |
|
#define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\ |
|
1715 |
{ \ |
{ \ |
1716 |
DEBUG_STATEMENT (fail_stack_elt_t failure_id;) \ |
DEBUG_STATEMENT (unsigned failure_id;) \ |
1717 |
int this_reg; \ |
active_reg_t this_reg; \ |
1718 |
const unsigned char *string_temp; \ |
const UCHAR_T *string_temp; \ |
1719 |
\ |
\ |
1720 |
assert (!FAIL_STACK_EMPTY ()); \ |
assert (!FAIL_STACK_EMPTY ()); \ |
1721 |
\ |
\ |
1732 |
/* If the saved string location is NULL, it came from an \ |
/* If the saved string location is NULL, it came from an \ |
1733 |
on_failure_keep_string_jump opcode, and we want to throw away the \ |
on_failure_keep_string_jump opcode, and we want to throw away the \ |
1734 |
saved NULL, thus retaining our current position in the string. */ \ |
saved NULL, thus retaining our current position in the string. */ \ |
1735 |
string_temp = POP_FAILURE_ITEM (); \ |
string_temp = POP_FAILURE_POINTER (); \ |
1736 |
if (string_temp != NULL) \ |
if (string_temp != NULL) \ |
1737 |
str = (const char *) string_temp; \ |
str = (const CHAR_T *) string_temp; \ |
1738 |
\ |
\ |
1739 |
DEBUG_PRINT2 (" Popping string 0x%x: `", str); \ |
DEBUG_PRINT2 (" Popping string %p: `", str); \ |
1740 |
DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2); \ |
DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2); \ |
1741 |
DEBUG_PRINT1 ("'\n"); \ |
DEBUG_PRINT1 ("'\n"); \ |
1742 |
\ |
\ |
1743 |
pat = (unsigned char *) POP_FAILURE_ITEM (); \ |
pat = (UCHAR_T *) POP_FAILURE_POINTER (); \ |
1744 |
DEBUG_PRINT2 (" Popping pattern 0x%x: ", pat); \ |
DEBUG_PRINT2 (" Popping pattern %p:\n", pat); \ |
1745 |
DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend); \ |
DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend); \ |
1746 |
\ |
\ |
1747 |
/* Restore register info. */ \ |
/* Restore register info. */ \ |
1748 |
high_reg = (unsigned) POP_FAILURE_ITEM (); \ |
high_reg = (active_reg_t) POP_FAILURE_INT (); \ |
1749 |
DEBUG_PRINT2 (" Popping high active reg: %d\n", high_reg); \ |
DEBUG_PRINT2 (" Popping high active reg: %ld\n", high_reg); \ |
1750 |
\ |
\ |
1751 |
low_reg = (unsigned) POP_FAILURE_ITEM (); \ |
low_reg = (active_reg_t) POP_FAILURE_INT (); \ |
1752 |
DEBUG_PRINT2 (" Popping low active reg: %d\n", low_reg); \ |
DEBUG_PRINT2 (" Popping low active reg: %ld\n", low_reg); \ |
1753 |
\ |
\ |
1754 |
for (this_reg = high_reg; this_reg >= low_reg; this_reg--) \ |
if (1) \ |
1755 |
{ \ |
for (this_reg = high_reg; this_reg >= low_reg; this_reg--) \ |
1756 |
DEBUG_PRINT2 (" Popping reg: %d\n", this_reg); \ |
{ \ |
1757 |
|
DEBUG_PRINT2 (" Popping reg: %ld\n", this_reg); \ |
1758 |
\ |
\ |
1759 |
reg_info[this_reg].word = POP_FAILURE_ITEM (); \ |
reg_info[this_reg].word = POP_FAILURE_ELT (); \ |
1760 |
DEBUG_PRINT2 (" info: 0x%x\n", reg_info[this_reg]); \ |
DEBUG_PRINT2 (" info: %p\n", \ |
1761 |
|
reg_info[this_reg].word.pointer); \ |
1762 |
\ |
\ |
1763 |
regend[this_reg] = (const char *) POP_FAILURE_ITEM (); \ |
regend[this_reg] = (const CHAR_T *) POP_FAILURE_POINTER (); \ |
1764 |
DEBUG_PRINT2 (" end: 0x%x\n", regend[this_reg]); \ |
DEBUG_PRINT2 (" end: %p\n", regend[this_reg]); \ |
1765 |
\ |
\ |
1766 |
regstart[this_reg] = (const char *) POP_FAILURE_ITEM (); \ |
regstart[this_reg] = (const CHAR_T *) POP_FAILURE_POINTER (); \ |
1767 |
DEBUG_PRINT2 (" start: 0x%x\n", regstart[this_reg]); \ |
DEBUG_PRINT2 (" start: %p\n", regstart[this_reg]); \ |
1768 |
|
} \ |
1769 |
|
else \ |
1770 |
|
{ \ |
1771 |
|
for (this_reg = highest_active_reg; this_reg > high_reg; this_reg--) \ |
1772 |
|
{ \ |
1773 |
|
reg_info[this_reg].word.integer = 0; \ |
1774 |
|
regend[this_reg] = 0; \ |
1775 |
|
regstart[this_reg] = 0; \ |
1776 |
|
} \ |
1777 |
|
highest_active_reg = high_reg; \ |
1778 |
} \ |
} \ |
1779 |
\ |
\ |
1780 |
|
set_regs_matched_done = 0; \ |
1781 |
DEBUG_STATEMENT (nfailure_points_popped++); \ |
DEBUG_STATEMENT (nfailure_points_popped++); \ |
1782 |
} /* POP_FAILURE_POINT */ |
} /* POP_FAILURE_POINT */ |
|
|
|
|
|
|
1783 |
|
|
1784 |
/* Structure for per-register (a.k.a. per-group) information. |
/* Structure for per-register (a.k.a. per-group) information. |
1785 |
This must not be longer than one word, because we push this value |
Other register information, such as the |
|
onto the failure stack. Other register information, such as the |
|
1786 |
starting and ending positions (which are addresses), and the list of |
starting and ending positions (which are addresses), and the list of |
1787 |
inner groups (which is a bits list) are maintained in separate |
inner groups (which is a bits list) are maintained in separate |
1788 |
variables. |
variables. |
1789 |
|
|
1790 |
We are making a (strictly speaking) nonportable assumption here: that |
We are making a (strictly speaking) nonportable assumption here: that |
1791 |
the compiler will pack our bit fields into something that fits into |
the compiler will pack our bit fields into something that fits into |
1792 |
the type of `word', i.e., is something that fits into one item on the |
the type of `word', i.e., is something that fits into one item on the |
1793 |
failure stack. */ |
failure stack. */ |
1794 |
|
|
1795 |
|
|
1796 |
|
/* Declarations and macros for re_match_2. */ |
1797 |
|
|
1798 |
typedef union |
typedef union |
1799 |
{ |
{ |
1800 |
fail_stack_elt_t word; |
PREFIX(fail_stack_elt_t) word; |
1801 |
struct |
struct |
1802 |
{ |
{ |
1803 |
/* This field is one if this group can match the empty string, |
/* This field is one if this group can match the empty string, |
1804 |
zero if not. If not yet determined, `MATCH_NULL_UNSET_VALUE'. */ |
zero if not. If not yet determined, `MATCH_NULL_UNSET_VALUE'. */ |
1805 |
#define MATCH_NULL_UNSET_VALUE 3 |
# define MATCH_NULL_UNSET_VALUE 3 |
1806 |
unsigned match_null_string_p : 2; |
unsigned match_null_string_p : 2; |
1807 |
unsigned is_active : 1; |
unsigned is_active : 1; |
1808 |
unsigned matched_something : 1; |
unsigned matched_something : 1; |
1809 |
unsigned ever_matched_something : 1; |
unsigned ever_matched_something : 1; |
1810 |
} bits; |
} bits; |
1811 |
} register_info_type; |
} PREFIX(register_info_type); |
1812 |
|
|
1813 |
#define REG_MATCH_NULL_STRING_P(R) ((R).bits.match_null_string_p) |
# ifndef DEFINED_ONCE |
1814 |
#define IS_ACTIVE(R) ((R).bits.is_active) |
# define REG_MATCH_NULL_STRING_P(R) ((R).bits.match_null_string_p) |
1815 |
#define MATCHED_SOMETHING(R) ((R).bits.matched_something) |
# define IS_ACTIVE(R) ((R).bits.is_active) |
1816 |
#define EVER_MATCHED_SOMETHING(R) ((R).bits.ever_matched_something) |
# define MATCHED_SOMETHING(R) ((R).bits.matched_something) |
1817 |
|
# define EVER_MATCHED_SOMETHING(R) ((R).bits.ever_matched_something) |
1818 |
|
|
1819 |
|
|
1820 |
/* Call this when have matched a real character; it sets `matched' flags |
/* Call this when have matched a real character; it sets `matched' flags |
1821 |
for the subexpressions which we are currently inside. Also records |
for the subexpressions which we are currently inside. Also records |
1822 |
that those subexprs have matched. */ |
that those subexprs have matched. */ |
1823 |
#define SET_REGS_MATCHED() \ |
# define SET_REGS_MATCHED() \ |
1824 |
do \ |
do \ |
1825 |
{ \ |
{ \ |
1826 |
unsigned r; \ |
if (!set_regs_matched_done) \ |
1827 |
for (r = lowest_active_reg; r <= highest_active_reg; r++) \ |
{ \ |
1828 |
{ \ |
active_reg_t r; \ |
1829 |
MATCHED_SOMETHING (reg_info[r]) \ |
set_regs_matched_done = 1; \ |
1830 |
= EVER_MATCHED_SOMETHING (reg_info[r]) \ |
for (r = lowest_active_reg; r <= highest_active_reg; r++) \ |
1831 |
= 1; \ |
{ \ |
1832 |
} \ |
MATCHED_SOMETHING (reg_info[r]) \ |
1833 |
|
= EVER_MATCHED_SOMETHING (reg_info[r]) \ |
1834 |
|
= 1; \ |
1835 |
|
} \ |
1836 |
|
} \ |
1837 |
} \ |
} \ |
1838 |
while (0) |
while (0) |
1839 |
|
# endif /* not DEFINED_ONCE */ |
1840 |
|
|
1841 |
/* Registers are set to a sentinel when they haven't yet matched. */ |
/* Registers are set to a sentinel when they haven't yet matched. */ |
1842 |
#define REG_UNSET_VALUE ((char *) -1) |
static CHAR_T PREFIX(reg_unset_dummy); |
1843 |
#define REG_UNSET(e) ((e) == REG_UNSET_VALUE) |
# define REG_UNSET_VALUE (&PREFIX(reg_unset_dummy)) |
1844 |
|
# define REG_UNSET(e) ((e) == REG_UNSET_VALUE) |
|
|
|
|
|
|
|
/* How do we implement a missing MATCH_MAY_ALLOCATE? |
|
|
We make the fail stack a global thing, and then grow it to |
|
|
re_max_failures when we compile. */ |
|
|
#ifndef MATCH_MAY_ALLOCATE |
|
|
static fail_stack_type fail_stack; |
|
|
|
|
|
static const char ** regstart, ** regend; |
|
|
static const char ** old_regstart, ** old_regend; |
|
|
static const char **best_regstart, **best_regend; |
|
|
static register_info_type *reg_info; |
|
|
static const char **reg_dummy; |
|
|
static register_info_type *reg_info_dummy; |
|
|
#endif |
|
1845 |
|
|
|
|
|
1846 |
/* Subroutine declarations and macros for regex_compile. */ |
/* Subroutine declarations and macros for regex_compile. */ |
1847 |
|
static void PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg); |
1848 |
|
static void PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc, |
1849 |
|
int arg1, int arg2); |
1850 |
|
static void PREFIX(insert_op1) (re_opcode_t op, UCHAR_T *loc, |
1851 |
|
int arg, UCHAR_T *end); |
1852 |
|
static void PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc, |
1853 |
|
int arg1, int arg2, UCHAR_T *end); |
1854 |
|
static boolean PREFIX(at_begline_loc_p) (const CHAR_T *pattern, |
1855 |
|
const CHAR_T *p, |
1856 |
|
reg_syntax_t syntax); |
1857 |
|
static boolean PREFIX(at_endline_loc_p) (const CHAR_T *p, |
1858 |
|
const CHAR_T *pend, |
1859 |
|
reg_syntax_t syntax); |
1860 |
|
# ifdef WCHAR |
1861 |
|
static reg_errcode_t wcs_compile_range (CHAR_T range_start, |
1862 |
|
const CHAR_T **p_ptr, |
1863 |
|
const CHAR_T *pend, |
1864 |
|
char *translate, |
1865 |
|
reg_syntax_t syntax, |
1866 |
|
UCHAR_T *b, |
1867 |
|
CHAR_T *char_set); |
1868 |
|
static void insert_space (int num, CHAR_T *loc, CHAR_T *end); |
1869 |
|
# else /* BYTE */ |
1870 |
|
static reg_errcode_t byte_compile_range (unsigned int range_start, |
1871 |
|
const char **p_ptr, |
1872 |
|
const char *pend, |
1873 |
|
char *translate, |
1874 |
|
reg_syntax_t syntax, |
1875 |
|
unsigned char *b); |
1876 |
|
# endif /* WCHAR */ |
1877 |
|
|
1878 |
static void store_op1 (), store_op2 (); |
/* Fetch the next character in the uncompiled pattern---translating it |
|
static void insert_op1 (), insert_op2 (); |
|
|
static boolean at_begline_loc_p (), at_endline_loc_p (); |
|
|
static boolean group_in_compile_stack (); |
|
|
static reg_errcode_t compile_range (); |
|
|
|
|
|
/* Fetch the next character in the uncompiled pattern---translating it |
|
1879 |
if necessary. Also cast from a signed character in the constant |
if necessary. Also cast from a signed character in the constant |
1880 |
string passed to us by the user to an unsigned char that we can use |
string passed to us by the user to an unsigned char that we can use |
1881 |
as an array index (in, e.g., `translate'). */ |
as an array index (in, e.g., `translate'). */ |
1882 |
#define PATFETCH(c) \ |
/* ifdef MBS_SUPPORT, we translate only if character <= 0xff, |
1883 |
|
because it is impossible to allocate 4GB array for some encodings |
1884 |
|
which have 4 byte character_set like UCS4. */ |
1885 |
|
# ifndef PATFETCH |
1886 |
|
# ifdef WCHAR |
1887 |
|
# define PATFETCH(c) \ |
1888 |
|
do {if (p == pend) return REG_EEND; \ |
1889 |
|
c = (UCHAR_T) *p++; \ |
1890 |
|
if (translate && (c <= 0xff)) c = (UCHAR_T) translate[c]; \ |
1891 |
|
} while (0) |
1892 |
|
# else /* BYTE */ |
1893 |
|
# define PATFETCH(c) \ |
1894 |
do {if (p == pend) return REG_EEND; \ |
do {if (p == pend) return REG_EEND; \ |
1895 |
c = (unsigned char) *p++; \ |
c = (unsigned char) *p++; \ |
1896 |
if (translate) c = translate[c]; \ |
if (translate) c = (unsigned char) translate[c]; \ |
1897 |
} while (0) |
} while (0) |
1898 |
|
# endif /* WCHAR */ |
1899 |
|
# endif |
1900 |
|
|
1901 |
/* Fetch the next character in the uncompiled pattern, with no |
/* Fetch the next character in the uncompiled pattern, with no |
1902 |
translation. */ |
translation. */ |
1903 |
#define PATFETCH_RAW(c) \ |
# define PATFETCH_RAW(c) \ |
1904 |
do {if (p == pend) return REG_EEND; \ |
do {if (p == pend) return REG_EEND; \ |
1905 |
c = (unsigned char) *p++; \ |
c = (UCHAR_T) *p++; \ |
1906 |
} while (0) |
} while (0) |
1907 |
|
|
1908 |
/* Go backwards one character in the pattern. */ |
/* Go backwards one character in the pattern. */ |
1909 |
#define PATUNFETCH p-- |
# define PATUNFETCH p-- |
1910 |
|
|
1911 |
|
|
1912 |
/* If `translate' is non-null, return translate[D], else just D. We |
/* If `translate' is non-null, return translate[D], else just D. We |
1913 |
cast the subscript to translate because some data is declared as |
cast the subscript to translate because some data is declared as |
1914 |
`char *', to avoid warnings when a string constant is passed. But |
`char *', to avoid warnings when a string constant is passed. But |
1915 |
when we use a character as a subscript we must make it unsigned. */ |
when we use a character as a subscript we must make it unsigned. */ |
1916 |
#define TRANSLATE(d) (translate ? translate[(unsigned char) (d)] : (d)) |
/* ifdef MBS_SUPPORT, we translate only if character <= 0xff, |
1917 |
|
because it is impossible to allocate 4GB array for some encodings |
1918 |
|
which have 4 byte character_set like UCS4. */ |
1919 |
|
|
1920 |
|
# ifndef TRANSLATE |
1921 |
|
# ifdef WCHAR |
1922 |
|
# define TRANSLATE(d) \ |
1923 |
|
((translate && ((UCHAR_T) (d)) <= 0xff) \ |
1924 |
|
? (char) translate[(unsigned char) (d)] : (d)) |
1925 |
|
# else /* BYTE */ |
1926 |
|
# define TRANSLATE(d) \ |
1927 |
|
(translate ? (char) translate[(unsigned char) (d)] : (d)) |
1928 |
|
# endif /* WCHAR */ |
1929 |
|
# endif |
1930 |
|
|
1931 |
|
|
1932 |
/* Macros for outputting the compiled pattern into `buffer'. */ |
/* Macros for outputting the compiled pattern into `buffer'. */ |
1933 |
|
|
1934 |
/* If the buffer isn't allocated when it comes in, use this. */ |
/* If the buffer isn't allocated when it comes in, use this. */ |
1935 |
#define INIT_BUF_SIZE 32 |
# define INIT_BUF_SIZE (32 * sizeof(UCHAR_T)) |
1936 |
|
|
1937 |
/* Make sure we have at least N more bytes of space in buffer. */ |
/* Make sure we have at least N more bytes of space in buffer. */ |
1938 |
#define GET_BUFFER_SPACE(n) \ |
# ifdef WCHAR |
1939 |
while (b - bufp->buffer + (n) > bufp->allocated) \ |
# define GET_BUFFER_SPACE(n) \ |
1940 |
|
while (((unsigned long)b - (unsigned long)COMPILED_BUFFER_VAR \ |
1941 |
|
+ (n)*sizeof(CHAR_T)) > bufp->allocated) \ |
1942 |
EXTEND_BUFFER () |
EXTEND_BUFFER () |
1943 |
|
# else /* BYTE */ |
1944 |
|
# define GET_BUFFER_SPACE(n) \ |
1945 |
|
while ((unsigned long) (b - bufp->buffer + (n)) > bufp->allocated) \ |
1946 |
|
EXTEND_BUFFER () |
1947 |
|
# endif /* WCHAR */ |
1948 |
|
|
1949 |
/* Make sure we have one more byte of buffer space and then add C to it. */ |
/* Make sure we have one more byte of buffer space and then add C to it. */ |
1950 |
#define BUF_PUSH(c) \ |
# define BUF_PUSH(c) \ |
1951 |
do { \ |
do { \ |
1952 |
GET_BUFFER_SPACE (1); \ |
GET_BUFFER_SPACE (1); \ |
1953 |
*b++ = (unsigned char) (c); \ |
*b++ = (UCHAR_T) (c); \ |
1954 |
} while (0) |
} while (0) |
1955 |
|
|
1956 |
|
|
1957 |
/* Ensure we have two more bytes of buffer space and then append C1 and C2. */ |
/* Ensure we have two more bytes of buffer space and then append C1 and C2. */ |
1958 |
#define BUF_PUSH_2(c1, c2) \ |
# define BUF_PUSH_2(c1, c2) \ |
1959 |
do { \ |
do { \ |
1960 |
GET_BUFFER_SPACE (2); \ |
GET_BUFFER_SPACE (2); \ |
1961 |
*b++ = (unsigned char) (c1); \ |
*b++ = (UCHAR_T) (c1); \ |
1962 |
*b++ = (unsigned char) (c2); \ |
*b++ = (UCHAR_T) (c2); \ |
1963 |
} while (0) |
} while (0) |
1964 |
|
|
1965 |
|
|
1966 |
/* As with BUF_PUSH_2, except for three bytes. */ |
/* As with BUF_PUSH_2, except for three bytes. */ |
1967 |
#define BUF_PUSH_3(c1, c2, c3) \ |
# define BUF_PUSH_3(c1, c2, c3) \ |
1968 |
do { \ |
do { \ |
1969 |
GET_BUFFER_SPACE (3); \ |
GET_BUFFER_SPACE (3); \ |
1970 |
*b++ = (unsigned char) (c1); \ |
*b++ = (UCHAR_T) (c1); \ |
1971 |
*b++ = (unsigned char) (c2); \ |
*b++ = (UCHAR_T) (c2); \ |
1972 |
*b++ = (unsigned char) (c3); \ |
*b++ = (UCHAR_T) (c3); \ |
1973 |
} while (0) |
} while (0) |
1974 |
|
|
|
|
|
1975 |
/* Store a jump with opcode OP at LOC to location TO. We store a |
/* Store a jump with opcode OP at LOC to location TO. We store a |
1976 |
relative address offset by the three bytes the jump itself occupies. */ |
relative address offset by the three bytes the jump itself occupies. */ |
1977 |
#define STORE_JUMP(op, loc, to) \ |
# define STORE_JUMP(op, loc, to) \ |
1978 |
store_op1 (op, loc, (to) - (loc) - 3) |
PREFIX(store_op1) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE))) |
1979 |
|
|
1980 |
/* Likewise, for a two-argument jump. */ |
/* Likewise, for a two-argument jump. */ |
1981 |
#define STORE_JUMP2(op, loc, to, arg) \ |
# define STORE_JUMP2(op, loc, to, arg) \ |
1982 |
store_op2 (op, loc, (to) - (loc) - 3, arg) |
PREFIX(store_op2) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)), arg) |
1983 |
|
|
1984 |
/* Like `STORE_JUMP', but for inserting. Assume `b' is the buffer end. */ |
/* Like `STORE_JUMP', but for inserting. Assume `b' is the buffer end. */ |
1985 |
#define INSERT_JUMP(op, loc, to) \ |
# define INSERT_JUMP(op, loc, to) \ |
1986 |
insert_op1 (op, loc, (to) - (loc) - 3, b) |
PREFIX(insert_op1) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)), b) |
1987 |
|
|
1988 |
/* Like `STORE_JUMP2', but for inserting. Assume `b' is the buffer end. */ |
/* Like `STORE_JUMP2', but for inserting. Assume `b' is the buffer end. */ |
1989 |
#define INSERT_JUMP2(op, loc, to, arg) \ |
# define INSERT_JUMP2(op, loc, to, arg) \ |
1990 |
insert_op2 (op, loc, (to) - (loc) - 3, arg, b) |
PREFIX(insert_op2) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)),\ |
1991 |
|
arg, b) |
1992 |
|
|
1993 |
/* This is not an arbitrary limit: the arguments which represent offsets |
/* This is not an arbitrary limit: the arguments which represent offsets |
1994 |
into the pattern are two bytes long. So if 2^16 bytes turns out to |
into the pattern are two bytes long. So if 2^16 bytes turns out to |
1995 |
be too small, many things would have to change. */ |
be too small, many things would have to change. */ |
1996 |
#define MAX_BUF_SIZE (1L << 16) |
/* Any other compiler which, like MSC, has allocation limit below 2^16 |
1997 |
|
bytes will have to use approach similar to what was done below for |
1998 |
|
MSC and drop MAX_BUF_SIZE a bit. Otherwise you may end up |
1999 |
|
reallocating to 0 bytes. Such thing is not going to work too well. |
2000 |
|
You have been warned!! */ |
2001 |
|
# ifndef DEFINED_ONCE |
2002 |
|
# if defined _MSC_VER && !defined WIN32 |
2003 |
|
/* Microsoft C 16-bit versions limit malloc to approx 65512 bytes. |
2004 |
|
The REALLOC define eliminates a flurry of conversion warnings, |
2005 |
|
but is not required. */ |
2006 |
|
# define MAX_BUF_SIZE 65500L |
2007 |
|
# define REALLOC(p,s) realloc ((p), (size_t) (s)) |
2008 |
|
# else |
2009 |
|
# define MAX_BUF_SIZE (1L << 16) |
2010 |
|
# define REALLOC(p,s) realloc ((p), (s)) |
2011 |
|
# endif |
2012 |
|
|
2013 |
/* Extend the buffer by twice its current size via realloc and |
/* Extend the buffer by twice its current size via realloc and |
2014 |
reset the pointers that pointed into the old block to point to the |
reset the pointers that pointed into the old block to point to the |
2015 |
correct places in the new one. If extending the buffer results in it |
correct places in the new one. If extending the buffer results in it |
2016 |
being larger than MAX_BUF_SIZE, then flag memory exhausted. */ |
being larger than MAX_BUF_SIZE, then flag memory exhausted. */ |
2017 |
#define EXTEND_BUFFER() \ |
# if __BOUNDED_POINTERS__ |
2018 |
do { \ |
# define SET_HIGH_BOUND(P) (__ptrhigh (P) = __ptrlow (P) + bufp->allocated) |
2019 |
unsigned char *old_buffer = bufp->buffer; \ |
# define MOVE_BUFFER_POINTER(P) \ |
2020 |
if (bufp->allocated == MAX_BUF_SIZE) \ |
(__ptrlow (P) += incr, SET_HIGH_BOUND (P), __ptrvalue (P) += incr) |
2021 |
|
# define ELSE_EXTEND_BUFFER_HIGH_BOUND \ |
2022 |
|
else \ |
2023 |
|
{ \ |
2024 |
|
SET_HIGH_BOUND (b); \ |
2025 |
|
SET_HIGH_BOUND (begalt); \ |
2026 |
|
if (fixup_alt_jump) \ |
2027 |
|
SET_HIGH_BOUND (fixup_alt_jump); \ |
2028 |
|
if (laststart) \ |
2029 |
|
SET_HIGH_BOUND (laststart); \ |
2030 |
|
if (pending_exact) \ |
2031 |
|
SET_HIGH_BOUND (pending_exact); \ |
2032 |
|
} |
2033 |
|
# else |
2034 |
|
# define MOVE_BUFFER_POINTER(P) (P) += incr |
2035 |
|
# define ELSE_EXTEND_BUFFER_HIGH_BOUND |
2036 |
|
# endif |
2037 |
|
# endif /* not DEFINED_ONCE */ |
2038 |
|
|
2039 |
|
# ifdef WCHAR |
2040 |
|
# define EXTEND_BUFFER() \ |
2041 |
|
do { \ |
2042 |
|
UCHAR_T *old_buffer = COMPILED_BUFFER_VAR; \ |
2043 |
|
int wchar_count; \ |
2044 |
|
if (bufp->allocated + sizeof(UCHAR_T) > MAX_BUF_SIZE) \ |
2045 |
return REG_ESIZE; \ |
return REG_ESIZE; \ |
2046 |
bufp->allocated <<= 1; \ |
bufp->allocated <<= 1; \ |
2047 |
if (bufp->allocated > MAX_BUF_SIZE) \ |
if (bufp->allocated > MAX_BUF_SIZE) \ |
2048 |
bufp->allocated = MAX_BUF_SIZE; \ |
bufp->allocated = MAX_BUF_SIZE; \ |
2049 |
bufp->buffer = (unsigned char *) realloc (bufp->buffer, bufp->allocated);\ |
/* How many characters the new buffer can have? */ \ |
2050 |
if (bufp->buffer == NULL) \ |
wchar_count = bufp->allocated / sizeof(UCHAR_T); \ |
2051 |
|
if (wchar_count == 0) wchar_count = 1; \ |
2052 |
|
/* Truncate the buffer to CHAR_T align. */ \ |
2053 |
|
bufp->allocated = wchar_count * sizeof(UCHAR_T); \ |
2054 |
|
RETALLOC (COMPILED_BUFFER_VAR, wchar_count, UCHAR_T); \ |
2055 |
|
bufp->buffer = (char*)COMPILED_BUFFER_VAR; \ |
2056 |
|
if (COMPILED_BUFFER_VAR == NULL) \ |
2057 |
return REG_ESPACE; \ |
return REG_ESPACE; \ |
2058 |
/* If the buffer moved, move all the pointers into it. */ \ |
/* If the buffer moved, move all the pointers into it. */ \ |
2059 |
if (old_buffer != bufp->buffer) \ |
if (old_buffer != COMPILED_BUFFER_VAR) \ |
2060 |
{ \ |
{ \ |
2061 |
b = (b - old_buffer) + bufp->buffer; \ |
int incr = COMPILED_BUFFER_VAR - old_buffer; \ |
2062 |
begalt = (begalt - old_buffer) + bufp->buffer; \ |
MOVE_BUFFER_POINTER (b); \ |
2063 |
if (fixup_alt_jump) \ |
MOVE_BUFFER_POINTER (begalt); \ |
2064 |
fixup_alt_jump = (fixup_alt_jump - old_buffer) + bufp->buffer;\ |
if (fixup_alt_jump) \ |
2065 |
if (laststart) \ |
MOVE_BUFFER_POINTER (fixup_alt_jump); \ |
2066 |
laststart = (laststart - old_buffer) + bufp->buffer; \ |
if (laststart) \ |
2067 |
if (pending_exact) \ |
MOVE_BUFFER_POINTER (laststart); \ |
2068 |
pending_exact = (pending_exact - old_buffer) + bufp->buffer; \ |
if (pending_exact) \ |
2069 |
|
MOVE_BUFFER_POINTER (pending_exact); \ |
2070 |
} \ |
} \ |
2071 |
|
ELSE_EXTEND_BUFFER_HIGH_BOUND \ |
2072 |
} while (0) |
} while (0) |
2073 |
|
# else /* BYTE */ |
2074 |
|
# define EXTEND_BUFFER() \ |
2075 |
|
do { \ |
2076 |
|
UCHAR_T *old_buffer = COMPILED_BUFFER_VAR; \ |
2077 |
|
if (bufp->allocated == MAX_BUF_SIZE) \ |
2078 |
|
return REG_ESIZE; \ |
2079 |
|
bufp->allocated <<= 1; \ |
2080 |
|
if (bufp->allocated > MAX_BUF_SIZE) \ |
2081 |
|
bufp->allocated = MAX_BUF_SIZE; \ |
2082 |
|
bufp->buffer = REALLOC (COMPILED_BUFFER_VAR, bufp->allocated); \ |
2083 |
|
if (COMPILED_BUFFER_VAR == NULL) \ |
2084 |
|
return REG_ESPACE; \ |
2085 |
|
/* If the buffer moved, move all the pointers into it. */ \ |
2086 |
|
if (old_buffer != COMPILED_BUFFER_VAR) \ |
2087 |
|
{ \ |
2088 |
|
int incr = COMPILED_BUFFER_VAR - old_buffer; \ |
2089 |
|
MOVE_BUFFER_POINTER (b); \ |
2090 |
|
MOVE_BUFFER_POINTER (begalt); \ |
2091 |
|
if (fixup_alt_jump) \ |
2092 |
|
MOVE_BUFFER_POINTER (fixup_alt_jump); \ |
2093 |
|
if (laststart) \ |
2094 |
|
MOVE_BUFFER_POINTER (laststart); \ |
2095 |
|
if (pending_exact) \ |
2096 |
|
MOVE_BUFFER_POINTER (pending_exact); \ |
2097 |
|
} \ |
2098 |
|
ELSE_EXTEND_BUFFER_HIGH_BOUND \ |
2099 |
|
} while (0) |
2100 |
|
# endif /* WCHAR */ |
2101 |
|
|
2102 |
|
# ifndef DEFINED_ONCE |
2103 |
/* Since we have one byte reserved for the register number argument to |
/* Since we have one byte reserved for the register number argument to |
2104 |
{start,stop}_memory, the maximum number of groups we can report |
{start,stop}_memory, the maximum number of groups we can report |
2105 |
things about is what fits in that byte. */ |
things about is what fits in that byte. */ |
2106 |
#define MAX_REGNUM 255 |
# define MAX_REGNUM 255 |
2107 |
|
|
2108 |
/* But patterns can have more than `MAX_REGNUM' registers. We just |
/* But patterns can have more than `MAX_REGNUM' registers. We just |
2109 |
ignore the excess. */ |
ignore the excess. */ |
2114 |
|
|
2115 |
/* Since offsets can go either forwards or backwards, this type needs to |
/* Since offsets can go either forwards or backwards, this type needs to |
2116 |
be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1. */ |
be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1. */ |
2117 |
typedef int pattern_offset_t; |
/* int may be not enough when sizeof(int) == 2. */ |
2118 |
|
typedef long pattern_offset_t; |
2119 |
|
|
2120 |
typedef struct |
typedef struct |
2121 |
{ |
{ |
2122 |
pattern_offset_t begalt_offset; |
pattern_offset_t begalt_offset; |
2123 |
pattern_offset_t fixup_alt_jump; |
pattern_offset_t fixup_alt_jump; |
2124 |
pattern_offset_t inner_group_offset; |
pattern_offset_t inner_group_offset; |
2125 |
pattern_offset_t laststart_offset; |
pattern_offset_t laststart_offset; |
2126 |
regnum_t regnum; |
regnum_t regnum; |
2127 |
} compile_stack_elt_t; |
} compile_stack_elt_t; |
2128 |
|
|
2135 |
} compile_stack_type; |
} compile_stack_type; |
2136 |
|
|
2137 |
|
|
2138 |
#define INIT_COMPILE_STACK_SIZE 32 |
# define INIT_COMPILE_STACK_SIZE 32 |
2139 |
|
|
2140 |
#define COMPILE_STACK_EMPTY (compile_stack.avail == 0) |
# define COMPILE_STACK_EMPTY (compile_stack.avail == 0) |
2141 |
#define COMPILE_STACK_FULL (compile_stack.avail == compile_stack.size) |
# define COMPILE_STACK_FULL (compile_stack.avail == compile_stack.size) |
2142 |
|
|
2143 |
/* The next available element. */ |
/* The next available element. */ |
2144 |
#define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail]) |
# define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail]) |
2145 |
|
|
2146 |
|
# endif /* not DEFINED_ONCE */ |
2147 |
|
|
2148 |
/* Set the bit for character C in a list. */ |
/* Set the bit for character C in a list. */ |
2149 |
#define SET_LIST_BIT(c) \ |
# ifndef DEFINED_ONCE |
2150 |
|
# define SET_LIST_BIT(c) \ |
2151 |
(b[((unsigned char) (c)) / BYTEWIDTH] \ |
(b[((unsigned char) (c)) / BYTEWIDTH] \ |
2152 |
|= 1 << (((unsigned char) c) % BYTEWIDTH)) |
|= 1 << (((unsigned char) c) % BYTEWIDTH)) |
2153 |
|
# endif /* DEFINED_ONCE */ |
2154 |
|
|
2155 |
/* Get the next unsigned number in the uncompiled pattern. */ |
/* Get the next unsigned number in the uncompiled pattern. */ |
2156 |
#define GET_UNSIGNED_NUMBER(num) \ |
# define GET_UNSIGNED_NUMBER(num) \ |
2157 |
{ if (p != pend) \ |
{ \ |
2158 |
{ \ |
while (p != pend) \ |
2159 |
PATFETCH (c); \ |
{ \ |
2160 |
while (ISDIGIT (c)) \ |
PATFETCH (c); \ |
2161 |
{ \ |
if (c < '0' || c > '9') \ |
2162 |
if (num < 0) \ |
break; \ |
2163 |
num = 0; \ |
if (num <= RE_DUP_MAX) \ |
2164 |
num = num * 10 + c - '0'; \ |
{ \ |
2165 |
if (p == pend) \ |
if (num < 0) \ |
2166 |
break; \ |
num = 0; \ |
2167 |
PATFETCH (c); \ |
num = num * 10 + c - '0'; \ |
2168 |
} \ |
} \ |
2169 |
} \ |
} \ |
2170 |
} |
} |
2171 |
|
|
2172 |
#define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */ |
# ifndef DEFINED_ONCE |
2173 |
|
# if defined _LIBC || WIDE_CHAR_SUPPORT |
2174 |
|
/* The GNU C library provides support for user-defined character classes |
2175 |
|
and the functions from ISO C amendement 1. */ |
2176 |
|
# ifdef CHARCLASS_NAME_MAX |
2177 |
|
# define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX |
2178 |
|
# else |
2179 |
|
/* This shouldn't happen but some implementation might still have this |
2180 |
|
problem. Use a reasonable default value. */ |
2181 |
|
# define CHAR_CLASS_MAX_LENGTH 256 |
2182 |
|
# endif |
2183 |
|
|
2184 |
|
# ifdef _LIBC |
2185 |
|
# define IS_CHAR_CLASS(string) __wctype (string) |
2186 |
|
# else |
2187 |
|
# define IS_CHAR_CLASS(string) wctype (string) |
2188 |
|
# endif |
2189 |
|
# else |
2190 |
|
# define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */ |
2191 |
|
|
2192 |
#define IS_CHAR_CLASS(string) \ |
# define IS_CHAR_CLASS(string) \ |
2193 |
(STREQ (string, "alpha") || STREQ (string, "upper") \ |
(STREQ (string, "alpha") || STREQ (string, "upper") \ |
2194 |
|| STREQ (string, "lower") || STREQ (string, "digit") \ |
|| STREQ (string, "lower") || STREQ (string, "digit") \ |
2195 |
|| STREQ (string, "alnum") || STREQ (string, "xdigit") \ |
|| STREQ (string, "alnum") || STREQ (string, "xdigit") \ |
2196 |
|| STREQ (string, "space") || STREQ (string, "print") \ |
|| STREQ (string, "space") || STREQ (string, "print") \ |
2197 |
|| STREQ (string, "punct") || STREQ (string, "graph") \ |
|| STREQ (string, "punct") || STREQ (string, "graph") \ |
2198 |
|| STREQ (string, "cntrl") || STREQ (string, "blank")) |
|| STREQ (string, "cntrl") || STREQ (string, "blank")) |
2199 |
|
# endif |
2200 |
|
# endif /* DEFINED_ONCE */ |
2201 |
|
|
2202 |
|
# ifndef MATCH_MAY_ALLOCATE |
2203 |
|
|
2204 |
|
/* If we cannot allocate large objects within re_match_2_internal, |
2205 |
|
we make the fail stack and register vectors global. |
2206 |
|
The fail stack, we grow to the maximum size when a regexp |
2207 |
|
is compiled. |
2208 |
|
The register vectors, we adjust in size each time we |
2209 |
|
compile a regexp, according to the number of registers it needs. */ |
2210 |
|
|
2211 |
|
static PREFIX(fail_stack_type) fail_stack; |
2212 |
|
|
2213 |
|
/* Size with which the following vectors are currently allocated. |
2214 |
|
That is so we can make them bigger as needed, |
2215 |
|
but never make them smaller. */ |
2216 |
|
# ifdef DEFINED_ONCE |
2217 |
|
static int regs_allocated_size; |
2218 |
|
|
2219 |
|
static const char ** regstart, ** regend; |
2220 |
|
static const char ** old_regstart, ** old_regend; |
2221 |
|
static const char **best_regstart, **best_regend; |
2222 |
|
static const char **reg_dummy; |
2223 |
|
# endif /* DEFINED_ONCE */ |
2224 |
|
|
2225 |
|
static PREFIX(register_info_type) *PREFIX(reg_info); |
2226 |
|
static PREFIX(register_info_type) *PREFIX(reg_info_dummy); |
2227 |
|
|
2228 |
|
/* Make the register vectors big enough for NUM_REGS registers, |
2229 |
|
but don't make them smaller. */ |
2230 |
|
|
2231 |
|
static void |
2232 |
|
PREFIX(regex_grow_registers) (int num_regs) |
2233 |
|
{ |
2234 |
|
if (num_regs > regs_allocated_size) |
2235 |
|
{ |
2236 |
|
RETALLOC_IF (regstart, num_regs, const char *); |
2237 |
|
RETALLOC_IF (regend, num_regs, const char *); |
2238 |
|
RETALLOC_IF (old_regstart, num_regs, const char *); |
2239 |
|
RETALLOC_IF (old_regend, num_regs, const char *); |
2240 |
|
RETALLOC_IF (best_regstart, num_regs, const char *); |
2241 |
|
RETALLOC_IF (best_regend, num_regs, const char *); |
2242 |
|
RETALLOC_IF (PREFIX(reg_info), num_regs, PREFIX(register_info_type)); |
2243 |
|
RETALLOC_IF (reg_dummy, num_regs, const char *); |
2244 |
|
RETALLOC_IF (PREFIX(reg_info_dummy), num_regs, PREFIX(register_info_type)); |
2245 |
|
|
2246 |
|
regs_allocated_size = num_regs; |
2247 |
|
} |
2248 |
|
} |
2249 |
|
|
2250 |
|
# endif /* not MATCH_MAY_ALLOCATE */ |
2251 |
|
|
2252 |
|
# ifndef DEFINED_ONCE |
2253 |
|
static boolean group_in_compile_stack (compile_stack_type |
2254 |
|
compile_stack, |
2255 |
|
regnum_t regnum); |
2256 |
|
# endif /* not DEFINED_ONCE */ |
2257 |
|
|
2258 |
/* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX. |
/* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX. |
2259 |
Returns one of error codes defined in `regex.h', or zero for success. |
Returns one of error codes defined in `regex.h', or zero for success. |
2260 |
|
|
2269 |
`fastmap_accurate' is zero; |
`fastmap_accurate' is zero; |
2270 |
`re_nsub' is the number of subexpressions in PATTERN; |
`re_nsub' is the number of subexpressions in PATTERN; |
2271 |
`not_bol' and `not_eol' are zero; |
`not_bol' and `not_eol' are zero; |
2272 |
|
|
2273 |
The `fastmap' and `newline_anchor' fields are neither |
The `fastmap' and `newline_anchor' fields are neither |
2274 |
examined nor set. */ |
examined nor set. */ |
2275 |
|
|
2276 |
/* Return, freeing storage we allocated. */ |
/* Return, freeing storage we allocated. */ |
2277 |
#define FREE_STACK_RETURN(value) \ |
# ifdef WCHAR |
2278 |
|
# define FREE_STACK_RETURN(value) \ |
2279 |
|
return (free(pattern), free(mbs_offset), free(is_binary), free (compile_stack.stack), value) |
2280 |
|
# else |
2281 |
|
# define FREE_STACK_RETURN(value) \ |
2282 |
return (free (compile_stack.stack), value) |
return (free (compile_stack.stack), value) |
2283 |
|
# endif /* WCHAR */ |
2284 |
|
|
2285 |
static reg_errcode_t |
static reg_errcode_t |
2286 |
regex_compile (pattern, size, syntax, bufp) |
PREFIX(regex_compile) (const char *ARG_PREFIX(pattern), |
2287 |
const char *pattern; |
size_t ARG_PREFIX(size), |
2288 |
int size; |
reg_syntax_t syntax, |
2289 |
reg_syntax_t syntax; |
struct re_pattern_buffer *bufp) |
|
struct re_pattern_buffer *bufp; |
|
2290 |
{ |
{ |
2291 |
/* We fetch characters from PATTERN here. Even though PATTERN is |
/* We fetch characters from PATTERN here. Even though PATTERN is |
2292 |
`char *' (i.e., signed), we declare these variables as unsigned, so |
`char *' (i.e., signed), we declare these variables as unsigned, so |
2293 |
they can be reliably used as array indices. */ |
they can be reliably used as array indices. */ |
2294 |
register unsigned char c, c1; |
register UCHAR_T c, c1; |
2295 |
|
|
2296 |
|
#ifdef WCHAR |
2297 |
|
/* A temporary space to keep wchar_t pattern and compiled pattern. */ |
2298 |
|
CHAR_T *pattern, *COMPILED_BUFFER_VAR; |
2299 |
|
size_t size; |
2300 |
|
/* offset buffer for optimization. See convert_mbs_to_wc. */ |
2301 |
|
int *mbs_offset = NULL; |
2302 |
|
/* It hold whether each wchar_t is binary data or not. */ |
2303 |
|
char *is_binary = NULL; |
2304 |
|
/* A flag whether exactn is handling binary data or not. */ |
2305 |
|
char is_exactn_bin = FALSE; |
2306 |
|
#endif /* WCHAR */ |
2307 |
|
|
2308 |
/* A random temporary spot in PATTERN. */ |
/* A random temporary spot in PATTERN. */ |
2309 |
const char *p1; |
const CHAR_T *p1; |
2310 |
|
|
2311 |
/* Points to the end of the buffer, where we should append. */ |
/* Points to the end of the buffer, where we should append. */ |
2312 |
register unsigned char *b; |
register UCHAR_T *b; |
2313 |
|
|
2314 |
/* Keeps track of unclosed groups. */ |
/* Keeps track of unclosed groups. */ |
2315 |
compile_stack_type compile_stack; |
compile_stack_type compile_stack; |
2316 |
|
|
2317 |
/* Points to the current (ending) position in the pattern. */ |
/* Points to the current (ending) position in the pattern. */ |
2318 |
const char *p = pattern; |
#ifdef WCHAR |
2319 |
const char *pend = pattern + size; |
const CHAR_T *p; |
2320 |
|
const CHAR_T *pend; |
2321 |
|
#else /* BYTE */ |
2322 |
|
const CHAR_T *p = pattern; |
2323 |
|
const CHAR_T *pend = pattern + size; |
2324 |
|
#endif /* WCHAR */ |
2325 |
|
|
2326 |
/* How to translate the characters in the pattern. */ |
/* How to translate the characters in the pattern. */ |
2327 |
char *translate = bufp->translate; |
RE_TRANSLATE_TYPE translate = bufp->translate; |
2328 |
|
|
2329 |
/* Address of the count-byte of the most recently inserted `exactn' |
/* Address of the count-byte of the most recently inserted `exactn' |
2330 |
command. This makes it possible to tell if a new exact-match |
command. This makes it possible to tell if a new exact-match |
2331 |
character can be added to that command or if the character requires |
character can be added to that command or if the character requires |
2332 |
a new `exactn' command. */ |
a new `exactn' command. */ |
2333 |
unsigned char *pending_exact = 0; |
UCHAR_T *pending_exact = 0; |
2334 |
|
|
2335 |
/* Address of start of the most recently finished expression. |
/* Address of start of the most recently finished expression. |
2336 |
This tells, e.g., postfix * where to find the start of its |
This tells, e.g., postfix * where to find the start of its |
2337 |
operand. Reset at the beginning of groups and alternatives. */ |
operand. Reset at the beginning of groups and alternatives. */ |
2338 |
unsigned char *laststart = 0; |
UCHAR_T *laststart = 0; |
2339 |
|
|
2340 |
/* Address of beginning of regexp, or inside of last group. */ |
/* Address of beginning of regexp, or inside of last group. */ |
2341 |
unsigned char *begalt; |
UCHAR_T *begalt; |
2342 |
|
|
|
/* Place in the uncompiled pattern (i.e., the {) to |
|
|
which to go back if the interval is invalid. */ |
|
|
const char *beg_interval; |
|
|
|
|
2343 |
/* Address of the place where a forward jump should go to the end of |
/* Address of the place where a forward jump should go to the end of |
2344 |
the containing expression. Each alternative of an `or' -- except the |
the containing expression. Each alternative of an `or' -- except the |
2345 |
last -- ends with a forward jump of this sort. */ |
last -- ends with a forward jump of this sort. */ |
2346 |
unsigned char *fixup_alt_jump = 0; |
UCHAR_T *fixup_alt_jump = 0; |
2347 |
|
|
2348 |
/* Counts open-groups as they are encountered. Remembered for the |
/* Counts open-groups as they are encountered. Remembered for the |
2349 |
matching close-group on the compile stack, so the same register |
matching close-group on the compile stack, so the same register |
2350 |
number is put in the stop_memory as the start_memory. */ |
number is put in the stop_memory as the start_memory. */ |
2351 |
regnum_t regnum = 0; |
regnum_t regnum = 0; |
2352 |
|
|
2353 |
|
#ifdef WCHAR |
2354 |
|
/* Initialize the wchar_t PATTERN and offset_buffer. */ |
2355 |
|
p = pend = pattern = TALLOC(csize + 1, CHAR_T); |
2356 |
|
mbs_offset = TALLOC(csize + 1, int); |
2357 |
|
is_binary = TALLOC(csize + 1, char); |
2358 |
|
if (pattern == NULL || mbs_offset == NULL || is_binary == NULL) |
2359 |
|
{ |
2360 |
|
free(pattern); |
2361 |
|
free(mbs_offset); |
2362 |
|
free(is_binary); |
2363 |
|
return REG_ESPACE; |
2364 |
|
} |
2365 |
|
pattern[csize] = L'\0'; /* sentinel */ |
2366 |
|
size = convert_mbs_to_wcs(pattern, cpattern, csize, mbs_offset, is_binary); |
2367 |
|
pend = p + size; |
2368 |
|
if (size < 0) |
2369 |
|
{ |
2370 |
|
free(pattern); |
2371 |
|
free(mbs_offset); |
2372 |
|
free(is_binary); |
2373 |
|
return REG_BADPAT; |
2374 |
|
} |
2375 |
|
#endif |
2376 |
|
|
2377 |
#ifdef DEBUG |
#ifdef DEBUG |
2378 |
DEBUG_PRINT1 ("\nCompiling pattern: "); |
DEBUG_PRINT1 ("\nCompiling pattern: "); |
2379 |
if (debug) |
if (debug) |
2380 |
{ |
{ |
2381 |
unsigned debug_count; |
unsigned debug_count; |
2382 |
|
|
2383 |
for (debug_count = 0; debug_count < size; debug_count++) |
for (debug_count = 0; debug_count < size; debug_count++) |
2384 |
printchar (pattern[debug_count]); |
PUT_CHAR (pattern[debug_count]); |
2385 |
putchar ('\n'); |
putchar ('\n'); |
2386 |
} |
} |
2387 |
#endif /* DEBUG */ |
#endif /* DEBUG */ |
2389 |
/* Initialize the compile stack. */ |
/* Initialize the compile stack. */ |
2390 |
compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t); |
compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t); |
2391 |
if (compile_stack.stack == NULL) |
if (compile_stack.stack == NULL) |
2392 |
return REG_ESPACE; |
{ |
2393 |
|
#ifdef WCHAR |
2394 |
|
free(pattern); |
2395 |
|
free(mbs_offset); |
2396 |
|
free(is_binary); |
2397 |
|
#endif |
2398 |
|
return REG_ESPACE; |
2399 |
|
} |
2400 |
|
|
2401 |
compile_stack.size = INIT_COMPILE_STACK_SIZE; |
compile_stack.size = INIT_COMPILE_STACK_SIZE; |
2402 |
compile_stack.avail = 0; |
compile_stack.avail = 0; |
2410 |
printer (for debugging) will think there's no pattern. We reset it |
printer (for debugging) will think there's no pattern. We reset it |
2411 |
at the end. */ |
at the end. */ |
2412 |
bufp->used = 0; |
bufp->used = 0; |
2413 |
|
|
2414 |
/* Always count groups, whether or not bufp->no_sub is set. */ |
/* Always count groups, whether or not bufp->no_sub is set. */ |
2415 |
bufp->re_nsub = 0; |
bufp->re_nsub = 0; |
2416 |
|
|
2417 |
#if !defined (emacs) && !defined (SYNTAX_TABLE) |
#if !defined emacs && !defined SYNTAX_TABLE |
2418 |
/* Initialize the syntax table. */ |
/* Initialize the syntax table. */ |
2419 |
init_syntax_once (); |
init_syntax_once (); |
2420 |
#endif |
#endif |
2425 |
{ /* If zero allocated, but buffer is non-null, try to realloc |
{ /* If zero allocated, but buffer is non-null, try to realloc |
2426 |
enough space. This loses if buffer's address is bogus, but |
enough space. This loses if buffer's address is bogus, but |
2427 |
that is the user's responsibility. */ |
that is the user's responsibility. */ |
2428 |
RETALLOC (bufp->buffer, INIT_BUF_SIZE, unsigned char); |
#ifdef WCHAR |
2429 |
|
/* Free bufp->buffer and allocate an array for wchar_t pattern |
2430 |
|
buffer. */ |
2431 |
|
free(bufp->buffer); |
2432 |
|
COMPILED_BUFFER_VAR = TALLOC (INIT_BUF_SIZE/sizeof(UCHAR_T), |
2433 |
|
UCHAR_T); |
2434 |
|
#else |
2435 |
|
RETALLOC (COMPILED_BUFFER_VAR, INIT_BUF_SIZE, UCHAR_T); |
2436 |
|
#endif /* WCHAR */ |
2437 |
} |
} |
2438 |
else |
else |
2439 |
{ /* Caller did not allocate a buffer. Do it for them. */ |
{ /* Caller did not allocate a buffer. Do it for them. */ |
2440 |
bufp->buffer = TALLOC (INIT_BUF_SIZE, unsigned char); |
COMPILED_BUFFER_VAR = TALLOC (INIT_BUF_SIZE / sizeof(UCHAR_T), |
2441 |
|
UCHAR_T); |
2442 |
} |
} |
|
if (!bufp->buffer) FREE_STACK_RETURN (REG_ESPACE); |
|
2443 |
|
|
2444 |
|
if (!COMPILED_BUFFER_VAR) FREE_STACK_RETURN (REG_ESPACE); |
2445 |
|
#ifdef WCHAR |
2446 |
|
bufp->buffer = (char*)COMPILED_BUFFER_VAR; |
2447 |
|
#endif /* WCHAR */ |
2448 |
bufp->allocated = INIT_BUF_SIZE; |
bufp->allocated = INIT_BUF_SIZE; |
2449 |
} |
} |
2450 |
|
#ifdef WCHAR |
2451 |
|
else |
2452 |
|
COMPILED_BUFFER_VAR = (UCHAR_T*) bufp->buffer; |
2453 |
|
#endif |
2454 |
|
|
2455 |
begalt = b = bufp->buffer; |
begalt = b = COMPILED_BUFFER_VAR; |
2456 |
|
|
2457 |
/* Loop through the uncompiled pattern until we're at the end. */ |
/* Loop through the uncompiled pattern until we're at the end. */ |
2458 |
while (p != pend) |
while (p != pend) |
2468 |
/* If context independent, it's an operator. */ |
/* If context independent, it's an operator. */ |
2469 |
|| syntax & RE_CONTEXT_INDEP_ANCHORS |
|| syntax & RE_CONTEXT_INDEP_ANCHORS |
2470 |
/* Otherwise, depends on what's come before. */ |
/* Otherwise, depends on what's come before. */ |
2471 |
|| at_begline_loc_p (pattern, p, syntax)) |
|| PREFIX(at_begline_loc_p) (pattern, p, syntax)) |
2472 |
BUF_PUSH (begline); |
BUF_PUSH (begline); |
2473 |
else |
else |
2474 |
goto normal_char; |
goto normal_char; |
2479 |
case '$': |
case '$': |
2480 |
{ |
{ |
2481 |
if ( /* If at end of pattern, it's an operator. */ |
if ( /* If at end of pattern, it's an operator. */ |
2482 |
p == pend |
p == pend |
2483 |
/* If context independent, it's an operator. */ |
/* If context independent, it's an operator. */ |
2484 |
|| syntax & RE_CONTEXT_INDEP_ANCHORS |
|| syntax & RE_CONTEXT_INDEP_ANCHORS |
2485 |
/* Otherwise, depends on what's next. */ |
/* Otherwise, depends on what's next. */ |
2486 |
|| at_endline_loc_p (p, pend, syntax)) |
|| PREFIX(at_endline_loc_p) (p, pend, syntax)) |
2487 |
BUF_PUSH (endline); |
BUF_PUSH (endline); |
2488 |
else |
else |
2489 |
goto normal_char; |
goto normal_char; |
2510 |
{ |
{ |
2511 |
/* Are we optimizing this jump? */ |
/* Are we optimizing this jump? */ |
2512 |
boolean keep_string_p = false; |
boolean keep_string_p = false; |
2513 |
|
|
2514 |
/* 1 means zero (many) matches is allowed. */ |
/* 1 means zero (many) matches is allowed. */ |
2515 |
char zero_times_ok = 0, many_times_ok = 0; |
char zero_times_ok = 0, many_times_ok = 0; |
2516 |
|
|
2558 |
|
|
2559 |
/* Star, etc. applied to an empty pattern is equivalent |
/* Star, etc. applied to an empty pattern is equivalent |
2560 |
to an empty pattern. */ |
to an empty pattern. */ |
2561 |
if (!laststart) |
if (!laststart) |
2562 |
break; |
break; |
2563 |
|
|
2564 |
/* Now we know whether or not zero matches is allowed |
/* Now we know whether or not zero matches is allowed |
2567 |
{ /* More than one repetition is allowed, so put in at the |
{ /* More than one repetition is allowed, so put in at the |
2568 |
end a backward relative jump from `b' to before the next |
end a backward relative jump from `b' to before the next |
2569 |
jump we're going to put in below (which jumps from |
jump we're going to put in below (which jumps from |
2570 |
laststart to after this jump). |
laststart to after this jump). |
2571 |
|
|
2572 |
But if we are at the `*' in the exact sequence `.*\n', |
But if we are at the `*' in the exact sequence `.*\n', |
2573 |
insert an unconditional jump backwards to the ., |
insert an unconditional jump backwards to the ., |
2577 |
assert (p - 1 > pattern); |
assert (p - 1 > pattern); |
2578 |
|
|
2579 |
/* Allocate the space for the jump. */ |
/* Allocate the space for the jump. */ |
2580 |
GET_BUFFER_SPACE (3); |
GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE); |
2581 |
|
|
2582 |
/* We know we are not at the first character of the pattern, |
/* We know we are not at the first character of the pattern, |
2583 |
because laststart was nonzero. And we've already |
because laststart was nonzero. And we've already |
2594 |
} |
} |
2595 |
else |
else |
2596 |
/* Anything else. */ |
/* Anything else. */ |
2597 |
STORE_JUMP (maybe_pop_jump, b, laststart - 3); |
STORE_JUMP (maybe_pop_jump, b, laststart - |
2598 |
|
(1 + OFFSET_ADDRESS_SIZE)); |
2599 |
|
|
2600 |
/* We've added more stuff to the buffer. */ |
/* We've added more stuff to the buffer. */ |
2601 |
b += 3; |
b += 1 + OFFSET_ADDRESS_SIZE; |
2602 |
} |
} |
2603 |
|
|
2604 |
/* On failure, jump from laststart to b + 3, which will be the |
/* On failure, jump from laststart to b + 3, which will be the |
2605 |
end of the buffer after this jump is inserted. */ |
end of the buffer after this jump is inserted. */ |
2606 |
GET_BUFFER_SPACE (3); |
/* ifdef WCHAR, 'b + 1 + OFFSET_ADDRESS_SIZE' instead of |
2607 |
|
'b + 3'. */ |
2608 |
|
GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE); |
2609 |
INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump |
INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump |
2610 |
: on_failure_jump, |
: on_failure_jump, |
2611 |
laststart, b + 3); |
laststart, b + 1 + OFFSET_ADDRESS_SIZE); |
2612 |
pending_exact = 0; |
pending_exact = 0; |
2613 |
b += 3; |
b += 1 + OFFSET_ADDRESS_SIZE; |
2614 |
|
|
2615 |
if (!zero_times_ok) |
if (!zero_times_ok) |
2616 |
{ |
{ |
2619 |
`on_failure_jump' instruction of the loop. This |
`on_failure_jump' instruction of the loop. This |
2620 |
effects a skip over that instruction the first time |
effects a skip over that instruction the first time |
2621 |
we hit that loop. */ |
we hit that loop. */ |
2622 |
GET_BUFFER_SPACE (3); |
GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE); |
2623 |
INSERT_JUMP (dummy_failure_jump, laststart, laststart + 6); |
INSERT_JUMP (dummy_failure_jump, laststart, laststart + |
2624 |
b += 3; |
2 + 2 * OFFSET_ADDRESS_SIZE); |
2625 |
|
b += 1 + OFFSET_ADDRESS_SIZE; |
2626 |
} |
} |
2627 |
} |
} |
2628 |
break; |
break; |
2637 |
case '[': |
case '[': |
2638 |
{ |
{ |
2639 |
boolean had_char_class = false; |
boolean had_char_class = false; |
2640 |
|
#ifdef WCHAR |
2641 |
|
CHAR_T range_start = 0xffffffff; |
2642 |
|
#else |
2643 |
|
unsigned int range_start = 0xffffffff; |
2644 |
|
#endif |
2645 |
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
2646 |
|
|
2647 |
|
#ifdef WCHAR |
2648 |
|
/* We assume a charset(_not) structure as a wchar_t array. |
2649 |
|
charset[0] = (re_opcode_t) charset(_not) |
2650 |
|
charset[1] = l (= length of char_classes) |
2651 |
|
charset[2] = m (= length of collating_symbols) |
2652 |
|
charset[3] = n (= length of equivalence_classes) |
2653 |
|
charset[4] = o (= length of char_ranges) |
2654 |
|
charset[5] = p (= length of chars) |
2655 |
|
|
2656 |
|
charset[6] = char_class (wctype_t) |
2657 |
|
charset[6+CHAR_CLASS_SIZE] = char_class (wctype_t) |
2658 |
|
... |
2659 |
|
charset[l+5] = char_class (wctype_t) |
2660 |
|
|
2661 |
|
charset[l+6] = collating_symbol (wchar_t) |
2662 |
|
... |
2663 |
|
charset[l+m+5] = collating_symbol (wchar_t) |
2664 |
|
ifdef _LIBC we use the index if |
2665 |
|
_NL_COLLATE_SYMB_EXTRAMB instead of |
2666 |
|
wchar_t string. |
2667 |
|
|
2668 |
|
charset[l+m+6] = equivalence_classes (wchar_t) |
2669 |
|
... |
2670 |
|
charset[l+m+n+5] = equivalence_classes (wchar_t) |
2671 |
|
ifdef _LIBC we use the index in |
2672 |
|
_NL_COLLATE_WEIGHT instead of |
2673 |
|
wchar_t string. |
2674 |
|
|
2675 |
|
charset[l+m+n+6] = range_start |
2676 |
|
charset[l+m+n+7] = range_end |
2677 |
|
... |
2678 |
|
charset[l+m+n+2o+4] = range_start |
2679 |
|
charset[l+m+n+2o+5] = range_end |
2680 |
|
ifdef _LIBC we use the value looked up |
2681 |
|
in _NL_COLLATE_COLLSEQ instead of |
2682 |
|
wchar_t character. |
2683 |
|
|
2684 |
|
charset[l+m+n+2o+6] = char |
2685 |
|
... |
2686 |
|
charset[l+m+n+2o+p+5] = char |
2687 |
|
|
2688 |
|
*/ |
2689 |
|
|
2690 |
|
/* We need at least 6 spaces: the opcode, the length of |
2691 |
|
char_classes, the length of collating_symbols, the length of |
2692 |
|
equivalence_classes, the length of char_ranges, the length of |
2693 |
|
chars. */ |
2694 |
|
GET_BUFFER_SPACE (6); |
2695 |
|
|
2696 |
|
/* Save b as laststart. And We use laststart as the pointer |
2697 |
|
to the first element of the charset here. |
2698 |
|
In other words, laststart[i] indicates charset[i]. */ |
2699 |
|
laststart = b; |
2700 |
|
|
2701 |
|
/* We test `*p == '^' twice, instead of using an if |
2702 |
|
statement, so we only need one BUF_PUSH. */ |
2703 |
|
BUF_PUSH (*p == '^' ? charset_not : charset); |
2704 |
|
if (*p == '^') |
2705 |
|
p++; |
2706 |
|
|
2707 |
|
/* Push the length of char_classes, the length of |
2708 |
|
collating_symbols, the length of equivalence_classes, the |
2709 |
|
length of char_ranges and the length of chars. */ |
2710 |
|
BUF_PUSH_3 (0, 0, 0); |
2711 |
|
BUF_PUSH_2 (0, 0); |
2712 |
|
|
2713 |
|
/* Remember the first position in the bracket expression. */ |
2714 |
|
p1 = p; |
2715 |
|
|
2716 |
|
/* charset_not matches newline according to a syntax bit. */ |
2717 |
|
if ((re_opcode_t) b[-6] == charset_not |
2718 |
|
&& (syntax & RE_HAT_LISTS_NOT_NEWLINE)) |
2719 |
|
{ |
2720 |
|
BUF_PUSH('\n'); |
2721 |
|
laststart[5]++; /* Update the length of characters */ |
2722 |
|
} |
2723 |
|
|
2724 |
|
/* Read in characters and ranges, setting map bits. */ |
2725 |
|
for (;;) |
2726 |
|
{ |
2727 |
|
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
2728 |
|
|
2729 |
|
PATFETCH (c); |
2730 |
|
|
2731 |
|
/* \ might escape characters inside [...] and [^...]. */ |
2732 |
|
if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\') |
2733 |
|
{ |
2734 |
|
if (p == pend) FREE_STACK_RETURN (REG_EESCAPE); |
2735 |
|
|
2736 |
|
PATFETCH (c1); |
2737 |
|
BUF_PUSH(c1); |
2738 |
|
laststart[5]++; /* Update the length of chars */ |
2739 |
|
range_start = c1; |
2740 |
|
continue; |
2741 |
|
} |
2742 |
|
|
2743 |
|
/* Could be the end of the bracket expression. If it's |
2744 |
|
not (i.e., when the bracket expression is `[]' so |
2745 |
|
far), the ']' character bit gets set way below. */ |
2746 |
|
if (c == ']' && p != p1 + 1) |
2747 |
|
break; |
2748 |
|
|
2749 |
|
/* Look ahead to see if it's a range when the last thing |
2750 |
|
was a character class. */ |
2751 |
|
if (had_char_class && c == '-' && *p != ']') |
2752 |
|
FREE_STACK_RETURN (REG_ERANGE); |
2753 |
|
|
2754 |
|
/* Look ahead to see if it's a range when the last thing |
2755 |
|
was a character: if this is a hyphen not at the |
2756 |
|
beginning or the end of a list, then it's the range |
2757 |
|
operator. */ |
2758 |
|
if (c == '-' |
2759 |
|
&& !(p - 2 >= pattern && p[-2] == '[') |
2760 |
|
&& !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^') |
2761 |
|
&& *p != ']') |
2762 |
|
{ |
2763 |
|
reg_errcode_t ret; |
2764 |
|
/* Allocate the space for range_start and range_end. */ |
2765 |
|
GET_BUFFER_SPACE (2); |
2766 |
|
/* Update the pointer to indicate end of buffer. */ |
2767 |
|
b += 2; |
2768 |
|
ret = wcs_compile_range (range_start, &p, pend, translate, |
2769 |
|
syntax, b, laststart); |
2770 |
|
if (ret != REG_NOERROR) FREE_STACK_RETURN (ret); |
2771 |
|
range_start = 0xffffffff; |
2772 |
|
} |
2773 |
|
else if (p[0] == '-' && p[1] != ']') |
2774 |
|
{ /* This handles ranges made up of characters only. */ |
2775 |
|
reg_errcode_t ret; |
2776 |
|
|
2777 |
|
/* Move past the `-'. */ |
2778 |
|
PATFETCH (c1); |
2779 |
|
/* Allocate the space for range_start and range_end. */ |
2780 |
|
GET_BUFFER_SPACE (2); |
2781 |
|
/* Update the pointer to indicate end of buffer. */ |
2782 |
|
b += 2; |
2783 |
|
ret = wcs_compile_range (c, &p, pend, translate, syntax, b, |
2784 |
|
laststart); |
2785 |
|
if (ret != REG_NOERROR) FREE_STACK_RETURN (ret); |
2786 |
|
range_start = 0xffffffff; |
2787 |
|
} |
2788 |
|
|
2789 |
|
/* See if we're at the beginning of a possible character |
2790 |
|
class. */ |
2791 |
|
else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':') |
2792 |
|
{ /* Leave room for the null. */ |
2793 |
|
char str[CHAR_CLASS_MAX_LENGTH + 1]; |
2794 |
|
|
2795 |
|
PATFETCH (c); |
2796 |
|
c1 = 0; |
2797 |
|
|
2798 |
|
/* If pattern is `[[:'. */ |
2799 |
|
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
2800 |
|
|
2801 |
|
for (;;) |
2802 |
|
{ |
2803 |
|
PATFETCH (c); |
2804 |
|
if ((c == ':' && *p == ']') || p == pend) |
2805 |
|
break; |
2806 |
|
if (c1 < CHAR_CLASS_MAX_LENGTH) |
2807 |
|
str[c1++] = c; |
2808 |
|
else |
2809 |
|
/* This is in any case an invalid class name. */ |
2810 |
|
str[0] = '\0'; |
2811 |
|
} |
2812 |
|
str[c1] = '\0'; |
2813 |
|
|
2814 |
|
/* If isn't a word bracketed by `[:' and `:]': |
2815 |
|
undo the ending character, the letters, and leave |
2816 |
|
the leading `:' and `[' (but store them as character). */ |
2817 |
|
if (c == ':' && *p == ']') |
2818 |
|
{ |
2819 |
|
wctype_t wt; |
2820 |
|
uintptr_t alignedp; |
2821 |
|
|
2822 |
|
/* Query the character class as wctype_t. */ |
2823 |
|
wt = IS_CHAR_CLASS (str); |
2824 |
|
if (wt == 0) |
2825 |
|
FREE_STACK_RETURN (REG_ECTYPE); |
2826 |
|
|
2827 |
|
/* Throw away the ] at the end of the character |
2828 |
|
class. */ |
2829 |
|
PATFETCH (c); |
2830 |
|
|
2831 |
|
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
2832 |
|
|
2833 |
|
/* Allocate the space for character class. */ |
2834 |
|
GET_BUFFER_SPACE(CHAR_CLASS_SIZE); |
2835 |
|
/* Update the pointer to indicate end of buffer. */ |
2836 |
|
b += CHAR_CLASS_SIZE; |
2837 |
|
/* Move data which follow character classes |
2838 |
|
not to violate the data. */ |
2839 |
|
insert_space(CHAR_CLASS_SIZE, |
2840 |
|
laststart + 6 + laststart[1], |
2841 |
|
b - 1); |
2842 |
|
alignedp = ((uintptr_t)(laststart + 6 + laststart[1]) |
2843 |
|
+ __alignof__(wctype_t) - 1) |
2844 |
|
& ~(uintptr_t)(__alignof__(wctype_t) - 1); |
2845 |
|
/* Store the character class. */ |
2846 |
|
*((wctype_t*)alignedp) = wt; |
2847 |
|
/* Update length of char_classes */ |
2848 |
|
laststart[1] += CHAR_CLASS_SIZE; |
2849 |
|
|
2850 |
|
had_char_class = true; |
2851 |
|
} |
2852 |
|
else |
2853 |
|
{ |
2854 |
|
c1++; |
2855 |
|
while (c1--) |
2856 |
|
PATUNFETCH; |
2857 |
|
BUF_PUSH ('['); |
2858 |
|
BUF_PUSH (':'); |
2859 |
|
laststart[5] += 2; /* Update the length of characters */ |
2860 |
|
range_start = ':'; |
2861 |
|
had_char_class = false; |
2862 |
|
} |
2863 |
|
} |
2864 |
|
else if (syntax & RE_CHAR_CLASSES && c == '[' && (*p == '=' |
2865 |
|
|| *p == '.')) |
2866 |
|
{ |
2867 |
|
CHAR_T str[128]; /* Should be large enough. */ |
2868 |
|
CHAR_T delim = *p; /* '=' or '.' */ |
2869 |
|
# ifdef _LIBC |
2870 |
|
uint32_t nrules = |
2871 |
|
_NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); |
2872 |
|
# endif |
2873 |
|
PATFETCH (c); |
2874 |
|
c1 = 0; |
2875 |
|
|
2876 |
|
/* If pattern is `[[=' or '[[.'. */ |
2877 |
|
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
2878 |
|
|
2879 |
|
for (;;) |
2880 |
|
{ |
2881 |
|
PATFETCH (c); |
2882 |
|
if ((c == delim && *p == ']') || p == pend) |
2883 |
|
break; |
2884 |
|
if (c1 < sizeof (str) - 1) |
2885 |
|
str[c1++] = c; |
2886 |
|
else |
2887 |
|
/* This is in any case an invalid class name. */ |
2888 |
|
str[0] = '\0'; |
2889 |
|
} |
2890 |
|
str[c1] = '\0'; |
2891 |
|
|
2892 |
|
if (c == delim && *p == ']' && str[0] != '\0') |
2893 |
|
{ |
2894 |
|
unsigned int i, offset; |
2895 |
|
/* If we have no collation data we use the default |
2896 |
|
collation in which each character is in a class |
2897 |
|
by itself. It also means that ASCII is the |
2898 |
|
character set and therefore we cannot have character |
2899 |
|
with more than one byte in the multibyte |
2900 |
|
representation. */ |
2901 |
|
|
2902 |
|
/* If not defined _LIBC, we push the name and |
2903 |
|
`\0' for the sake of matching performance. */ |
2904 |
|
int datasize = c1 + 1; |
2905 |
|
|
2906 |
|
# ifdef _LIBC |
2907 |
|
int32_t idx = 0; |
2908 |
|
if (nrules == 0) |
2909 |
|
# endif |
2910 |
|
{ |
2911 |
|
if (c1 != 1) |
2912 |
|
FREE_STACK_RETURN (REG_ECOLLATE); |
2913 |
|
} |
2914 |
|
# ifdef _LIBC |
2915 |
|
else |
2916 |
|
{ |
2917 |
|
const int32_t *table; |
2918 |
|
const int32_t *weights; |
2919 |
|
const int32_t *extra; |
2920 |
|
const int32_t *indirect; |
2921 |
|
wint_t *cp; |
2922 |
|
|
2923 |
|
/* This #include defines a local function! */ |
2924 |
|
# include <locale/weightwc.h> |
2925 |
|
|
2926 |
|
if(delim == '=') |
2927 |
|
{ |
2928 |
|
/* We push the index for equivalence class. */ |
2929 |
|
cp = (wint_t*)str; |
2930 |
|
|
2931 |
|
table = (const int32_t *) |
2932 |
|
_NL_CURRENT (LC_COLLATE, |
2933 |
|
_NL_COLLATE_TABLEWC); |
2934 |
|
weights = (const int32_t *) |
2935 |
|
_NL_CURRENT (LC_COLLATE, |
2936 |
|
_NL_COLLATE_WEIGHTWC); |
2937 |
|
extra = (const int32_t *) |
2938 |
|
_NL_CURRENT (LC_COLLATE, |
2939 |
|
_NL_COLLATE_EXTRAWC); |
2940 |
|
indirect = (const int32_t *) |
2941 |
|
_NL_CURRENT (LC_COLLATE, |
2942 |
|
_NL_COLLATE_INDIRECTWC); |
2943 |
|
|
2944 |
|
idx = findidx ((const wint_t**)&cp); |
2945 |
|
if (idx == 0 || cp < (wint_t*) str + c1) |
2946 |
|
/* This is no valid character. */ |
2947 |
|
FREE_STACK_RETURN (REG_ECOLLATE); |
2948 |
|
|
2949 |
|
str[0] = (wchar_t)idx; |
2950 |
|
} |
2951 |
|
else /* delim == '.' */ |
2952 |
|
{ |
2953 |
|
/* We push collation sequence value |
2954 |
|
for collating symbol. */ |
2955 |
|
int32_t table_size; |
2956 |
|
const int32_t *symb_table; |
2957 |
|
const unsigned char *extra; |
2958 |
|
int32_t idx; |
2959 |
|
int32_t elem; |
2960 |
|
int32_t second; |
2961 |
|
int32_t hash; |
2962 |
|
char char_str[c1]; |
2963 |
|
|
2964 |
|
/* We have to convert the name to a single-byte |
2965 |
|
string. This is possible since the names |
2966 |
|
consist of ASCII characters and the internal |
2967 |
|
representation is UCS4. */ |
2968 |
|
for (i = 0; i < c1; ++i) |
2969 |
|
char_str[i] = str[i]; |
2970 |
|
|
2971 |
|
table_size = |
2972 |
|
_NL_CURRENT_WORD (LC_COLLATE, |
2973 |
|
_NL_COLLATE_SYMB_HASH_SIZEMB); |
2974 |
|
symb_table = (const int32_t *) |
2975 |
|
_NL_CURRENT (LC_COLLATE, |
2976 |
|
_NL_COLLATE_SYMB_TABLEMB); |
2977 |
|
extra = (const unsigned char *) |
2978 |
|
_NL_CURRENT (LC_COLLATE, |
2979 |
|
_NL_COLLATE_SYMB_EXTRAMB); |
2980 |
|
|
2981 |
|
/* Locate the character in the hashing table. */ |
2982 |
|
hash = elem_hash (char_str, c1); |
2983 |
|
|
2984 |
|
idx = 0; |
2985 |
|
elem = hash % table_size; |
2986 |
|
second = hash % (table_size - 2); |
2987 |
|
while (symb_table[2 * elem] != 0) |
2988 |
|
{ |
2989 |
|
/* First compare the hashing value. */ |
2990 |
|
if (symb_table[2 * elem] == hash |
2991 |
|
&& c1 == extra[symb_table[2 * elem + 1]] |
2992 |
|
&& memcmp (char_str, |
2993 |
|
&extra[symb_table[2 * elem + 1] |
2994 |
|
+ 1], c1) == 0) |
2995 |
|
{ |
2996 |
|
/* Yep, this is the entry. */ |
2997 |
|
idx = symb_table[2 * elem + 1]; |
2998 |
|
idx += 1 + extra[idx]; |
2999 |
|
break; |
3000 |
|
} |
3001 |
|
|
3002 |
|
/* Next entry. */ |
3003 |
|
elem += second; |
3004 |
|
} |
3005 |
|
|
3006 |
|
if (symb_table[2 * elem] != 0) |
3007 |
|
{ |
3008 |
|
/* Compute the index of the byte sequence |
3009 |
|
in the table. */ |
3010 |
|
idx += 1 + extra[idx]; |
3011 |
|
/* Adjust for the alignment. */ |
3012 |
|
idx = (idx + 3) & ~3; |
3013 |
|
|
3014 |
|
str[0] = (wchar_t) idx + 4; |
3015 |
|
} |
3016 |
|
else if (symb_table[2 * elem] == 0 && c1 == 1) |
3017 |
|
{ |
3018 |
|
/* No valid character. Match it as a |
3019 |
|
single byte character. */ |
3020 |
|
had_char_class = false; |
3021 |
|
BUF_PUSH(str[0]); |
3022 |
|
/* Update the length of characters */ |
3023 |
|
laststart[5]++; |
3024 |
|
range_start = str[0]; |
3025 |
|
|
3026 |
|
/* Throw away the ] at the end of the |
3027 |
|
collating symbol. */ |
3028 |
|
PATFETCH (c); |
3029 |
|
/* exit from the switch block. */ |
3030 |
|
continue; |
3031 |
|
} |
3032 |
|
else |
3033 |
|
FREE_STACK_RETURN (REG_ECOLLATE); |
3034 |
|
} |
3035 |
|
datasize = 1; |
3036 |
|
} |
3037 |
|
# endif |
3038 |
|
/* Throw away the ] at the end of the equivalence |
3039 |
|
class (or collating symbol). */ |
3040 |
|
PATFETCH (c); |
3041 |
|
|
3042 |
|
/* Allocate the space for the equivalence class |
3043 |
|
(or collating symbol) (and '\0' if needed). */ |
3044 |
|
GET_BUFFER_SPACE(datasize); |
3045 |
|
/* Update the pointer to indicate end of buffer. */ |
3046 |
|
b += datasize; |
3047 |
|
|
3048 |
|
if (delim == '=') |
3049 |
|
{ /* equivalence class */ |
3050 |
|
/* Calculate the offset of char_ranges, |
3051 |
|
which is next to equivalence_classes. */ |
3052 |
|
offset = laststart[1] + laststart[2] |
3053 |
|
+ laststart[3] +6; |
3054 |
|
/* Insert space. */ |
3055 |
|
insert_space(datasize, laststart + offset, b - 1); |
3056 |
|
|
3057 |
|
/* Write the equivalence_class and \0. */ |
3058 |
|
for (i = 0 ; i < datasize ; i++) |
3059 |
|
laststart[offset + i] = str[i]; |
3060 |
|
|
3061 |
|
/* Update the length of equivalence_classes. */ |
3062 |
|
laststart[3] += datasize; |
3063 |
|
had_char_class = true; |
3064 |
|
} |
3065 |
|
else /* delim == '.' */ |
3066 |
|
{ /* collating symbol */ |
3067 |
|
/* Calculate the offset of the equivalence_classes, |
3068 |
|
which is next to collating_symbols. */ |
3069 |
|
offset = laststart[1] + laststart[2] + 6; |
3070 |
|
/* Insert space and write the collationg_symbol |
3071 |
|
and \0. */ |
3072 |
|
insert_space(datasize, laststart + offset, b-1); |
3073 |
|
for (i = 0 ; i < datasize ; i++) |
3074 |
|
laststart[offset + i] = str[i]; |
3075 |
|
|
3076 |
|
/* In re_match_2_internal if range_start < -1, we |
3077 |
|
assume -range_start is the offset of the |
3078 |
|
collating symbol which is specified as |
3079 |
|
the character of the range start. So we assign |
3080 |
|
-(laststart[1] + laststart[2] + 6) to |
3081 |
|
range_start. */ |
3082 |
|
range_start = -(laststart[1] + laststart[2] + 6); |
3083 |
|
/* Update the length of collating_symbol. */ |
3084 |
|
laststart[2] += datasize; |
3085 |
|
had_char_class = false; |
3086 |
|
} |
3087 |
|
} |
3088 |
|
else |
3089 |
|
{ |
3090 |
|
c1++; |
3091 |
|
while (c1--) |
3092 |
|
PATUNFETCH; |
3093 |
|
BUF_PUSH ('['); |
3094 |
|
BUF_PUSH (delim); |
3095 |
|
laststart[5] += 2; /* Update the length of characters */ |
3096 |
|
range_start = delim; |
3097 |
|
had_char_class = false; |
3098 |
|
} |
3099 |
|
} |
3100 |
|
else |
3101 |
|
{ |
3102 |
|
had_char_class = false; |
3103 |
|
BUF_PUSH(c); |
3104 |
|
laststart[5]++; /* Update the length of characters */ |
3105 |
|
range_start = c; |
3106 |
|
} |
3107 |
|
} |
3108 |
|
|
3109 |
|
#else /* BYTE */ |
3110 |
/* Ensure that we have enough space to push a charset: the |
/* Ensure that we have enough space to push a charset: the |
3111 |
opcode, the length count, and the bitset; 34 bytes in all. */ |
opcode, the length count, and the bitset; 34 bytes in all. */ |
3112 |
GET_BUFFER_SPACE (34); |
GET_BUFFER_SPACE (34); |
3115 |
|
|
3116 |
/* We test `*p == '^' twice, instead of using an if |
/* We test `*p == '^' twice, instead of using an if |
3117 |
statement, so we only need one BUF_PUSH. */ |
statement, so we only need one BUF_PUSH. */ |
3118 |
BUF_PUSH (*p == '^' ? charset_not : charset); |
BUF_PUSH (*p == '^' ? charset_not : charset); |
3119 |
if (*p == '^') |
if (*p == '^') |
3120 |
p++; |
p++; |
3121 |
|
|
3147 |
|
|
3148 |
PATFETCH (c1); |
PATFETCH (c1); |
3149 |
SET_LIST_BIT (c1); |
SET_LIST_BIT (c1); |
3150 |
|
range_start = c1; |
3151 |
continue; |
continue; |
3152 |
} |
} |
3153 |
|
|
3166 |
was a character: if this is a hyphen not at the |
was a character: if this is a hyphen not at the |
3167 |
beginning or the end of a list, then it's the range |
beginning or the end of a list, then it's the range |
3168 |
operator. */ |
operator. */ |
3169 |
if (c == '-' |
if (c == '-' |
3170 |
&& !(p - 2 >= pattern && p[-2] == '[') |
&& !(p - 2 >= pattern && p[-2] == '[') |
3171 |
&& !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^') |
&& !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^') |
3172 |
&& *p != ']') |
&& *p != ']') |
3173 |
{ |
{ |
3174 |
reg_errcode_t ret |
reg_errcode_t ret |
3175 |
= compile_range (&p, pend, translate, syntax, b); |
= byte_compile_range (range_start, &p, pend, translate, |
3176 |
|
syntax, b); |
3177 |
if (ret != REG_NOERROR) FREE_STACK_RETURN (ret); |
if (ret != REG_NOERROR) FREE_STACK_RETURN (ret); |
3178 |
|
range_start = 0xffffffff; |
3179 |
} |
} |
3180 |
|
|
3181 |
else if (p[0] == '-' && p[1] != ']') |
else if (p[0] == '-' && p[1] != ']') |
3184 |
|
|
3185 |
/* Move past the `-'. */ |
/* Move past the `-'. */ |
3186 |
PATFETCH (c1); |
PATFETCH (c1); |
3187 |
|
|
3188 |
ret = compile_range (&p, pend, translate, syntax, b); |
ret = byte_compile_range (c, &p, pend, translate, syntax, b); |
3189 |
if (ret != REG_NOERROR) FREE_STACK_RETURN (ret); |
if (ret != REG_NOERROR) FREE_STACK_RETURN (ret); |
3190 |
|
range_start = 0xffffffff; |
3191 |
} |
} |
3192 |
|
|
3193 |
/* See if we're at the beginning of a possible character |
/* See if we're at the beginning of a possible character |
3206 |
for (;;) |
for (;;) |
3207 |
{ |
{ |
3208 |
PATFETCH (c); |
PATFETCH (c); |
3209 |
if (c == ':' || c == ']' || p == pend |
if ((c == ':' && *p == ']') || p == pend) |
|
|| c1 == CHAR_CLASS_MAX_LENGTH) |
|
3210 |
break; |
break; |
3211 |
str[c1++] = c; |
if (c1 < CHAR_CLASS_MAX_LENGTH) |
3212 |
|
str[c1++] = c; |
3213 |
|
else |
3214 |
|
/* This is in any case an invalid class name. */ |
3215 |
|
str[0] = '\0'; |
3216 |
} |
} |
3217 |
str[c1] = '\0'; |
str[c1] = '\0'; |
3218 |
|
|
3219 |
/* If isn't a word bracketed by `[:' and:`]': |
/* If isn't a word bracketed by `[:' and `:]': |
3220 |
undo the ending character, the letters, and leave |
undo the ending character, the letters, and leave |
3221 |
the leading `:' and `[' (but set bits for them). */ |
the leading `:' and `[' (but set bits for them). */ |
3222 |
if (c == ':' && *p == ']') |
if (c == ':' && *p == ']') |
3223 |
{ |
{ |
3224 |
|
# if defined _LIBC || WIDE_CHAR_SUPPORT |
3225 |
|
boolean is_lower = STREQ (str, "lower"); |
3226 |
|
boolean is_upper = STREQ (str, "upper"); |
3227 |
|
wctype_t wt; |
3228 |
|
int ch; |
3229 |
|
|
3230 |
|
wt = IS_CHAR_CLASS (str); |
3231 |
|
if (wt == 0) |
3232 |
|
FREE_STACK_RETURN (REG_ECTYPE); |
3233 |
|
|
3234 |
|
/* Throw away the ] at the end of the character |
3235 |
|
class. */ |
3236 |
|
PATFETCH (c); |
3237 |
|
|
3238 |
|
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
3239 |
|
|
3240 |
|
for (ch = 0; ch < 1 << BYTEWIDTH; ++ch) |
3241 |
|
{ |
3242 |
|
if (iswctype (btowc (ch), wt)) |
3243 |
|
SET_LIST_BIT (ch); |
3244 |
|
|
3245 |
|
if (translate && (is_upper || is_lower) |
3246 |
|
&& (ISUPPER (ch) || ISLOWER (ch))) |
3247 |
|
SET_LIST_BIT (ch); |
3248 |
|
} |
3249 |
|
|
3250 |
|
had_char_class = true; |
3251 |
|
# else |
3252 |
int ch; |
int ch; |
3253 |
boolean is_alnum = STREQ (str, "alnum"); |
boolean is_alnum = STREQ (str, "alnum"); |
3254 |
boolean is_alpha = STREQ (str, "alpha"); |
boolean is_alpha = STREQ (str, "alpha"); |
3262 |
boolean is_space = STREQ (str, "space"); |
boolean is_space = STREQ (str, "space"); |
3263 |
boolean is_upper = STREQ (str, "upper"); |
boolean is_upper = STREQ (str, "upper"); |
3264 |
boolean is_xdigit = STREQ (str, "xdigit"); |
boolean is_xdigit = STREQ (str, "xdigit"); |
3265 |
|
|
3266 |
if (!IS_CHAR_CLASS (str)) |
if (!IS_CHAR_CLASS (str)) |
3267 |
FREE_STACK_RETURN (REG_ECTYPE); |
FREE_STACK_RETURN (REG_ECTYPE); |
3268 |
|
|
3269 |
/* Throw away the ] at the end of the character |
/* Throw away the ] at the end of the character |
3270 |
class. */ |
class. */ |
3271 |
PATFETCH (c); |
PATFETCH (c); |
3272 |
|
|
3273 |
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
3274 |
|
|
3291 |
|| (is_upper && ISUPPER (ch)) |
|| (is_upper && ISUPPER (ch)) |
3292 |
|| (is_xdigit && ISXDIGIT (ch))) |
|| (is_xdigit && ISXDIGIT (ch))) |
3293 |
SET_LIST_BIT (ch); |
SET_LIST_BIT (ch); |
3294 |
|
if ( translate && (is_upper || is_lower) |
3295 |
|
&& (ISUPPER (ch) || ISLOWER (ch))) |
3296 |
|
SET_LIST_BIT (ch); |
3297 |
} |
} |
3298 |
had_char_class = true; |
had_char_class = true; |
3299 |
|
# endif /* libc || wctype.h */ |
3300 |
} |
} |
3301 |
else |
else |
3302 |
{ |
{ |
3303 |
c1++; |
c1++; |
3304 |
while (c1--) |
while (c1--) |
3305 |
PATUNFETCH; |
PATUNFETCH; |
3306 |
SET_LIST_BIT ('['); |
SET_LIST_BIT ('['); |
3307 |
SET_LIST_BIT (':'); |
SET_LIST_BIT (':'); |
3308 |
|
range_start = ':'; |
3309 |
had_char_class = false; |
had_char_class = false; |
3310 |
} |
} |
3311 |
} |
} |
3312 |
|
else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '=') |
3313 |
|
{ |
3314 |
|
unsigned char str[MB_LEN_MAX + 1]; |
3315 |
|
# ifdef _LIBC |
3316 |
|
uint32_t nrules = |
3317 |
|
_NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); |
3318 |
|
# endif |
3319 |
|
|
3320 |
|
PATFETCH (c); |
3321 |
|
c1 = 0; |
3322 |
|
|
3323 |
|
/* If pattern is `[[='. */ |
3324 |
|
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
3325 |
|
|
3326 |
|
for (;;) |
3327 |
|
{ |
3328 |
|
PATFETCH (c); |
3329 |
|
if ((c == '=' && *p == ']') || p == pend) |
3330 |
|
break; |
3331 |
|
if (c1 < MB_LEN_MAX) |
3332 |
|
str[c1++] = c; |
3333 |
|
else |
3334 |
|
/* This is in any case an invalid class name. */ |
3335 |
|
str[0] = '\0'; |
3336 |
|
} |
3337 |
|
str[c1] = '\0'; |
3338 |
|
|
3339 |
|
if (c == '=' && *p == ']' && str[0] != '\0') |
3340 |
|
{ |
3341 |
|
/* If we have no collation data we use the default |
3342 |
|
collation in which each character is in a class |
3343 |
|
by itself. It also means that ASCII is the |
3344 |
|
character set and therefore we cannot have character |
3345 |
|
with more than one byte in the multibyte |
3346 |
|
representation. */ |
3347 |
|
# ifdef _LIBC |
3348 |
|
if (nrules == 0) |
3349 |
|
# endif |
3350 |
|
{ |
3351 |
|
if (c1 != 1) |
3352 |
|
FREE_STACK_RETURN (REG_ECOLLATE); |
3353 |
|
|
3354 |
|
/* Throw away the ] at the end of the equivalence |
3355 |
|
class. */ |
3356 |
|
PATFETCH (c); |
3357 |
|
|
3358 |
|
/* Set the bit for the character. */ |
3359 |
|
SET_LIST_BIT (str[0]); |
3360 |
|
} |
3361 |
|
# ifdef _LIBC |
3362 |
|
else |
3363 |
|
{ |
3364 |
|
/* Try to match the byte sequence in `str' against |
3365 |
|
those known to the collate implementation. |
3366 |
|
First find out whether the bytes in `str' are |
3367 |
|
actually from exactly one character. */ |
3368 |
|
const int32_t *table; |
3369 |
|
const unsigned char *weights; |
3370 |
|
const unsigned char *extra; |
3371 |
|
const int32_t *indirect; |
3372 |
|
int32_t idx; |
3373 |
|
const unsigned char *cp = str; |
3374 |
|
int ch; |
3375 |
|
|
3376 |
|
/* This #include defines a local function! */ |
3377 |
|
# include <locale/weight.h> |
3378 |
|
|
3379 |
|
table = (const int32_t *) |
3380 |
|
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB); |
3381 |
|
weights = (const unsigned char *) |
3382 |
|
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB); |
3383 |
|
extra = (const unsigned char *) |
3384 |
|
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB); |
3385 |
|
indirect = (const int32_t *) |
3386 |
|
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB); |
3387 |
|
|
3388 |
|
idx = findidx (&cp); |
3389 |
|
if (idx == 0 || cp < str + c1) |
3390 |
|
/* This is no valid character. */ |
3391 |
|
FREE_STACK_RETURN (REG_ECOLLATE); |
3392 |
|
|
3393 |
|
/* Throw away the ] at the end of the equivalence |
3394 |
|
class. */ |
3395 |
|
PATFETCH (c); |
3396 |
|
|
3397 |
|
/* Now we have to go throught the whole table |
3398 |
|
and find all characters which have the same |
3399 |
|
first level weight. |
3400 |
|
|
3401 |
|
XXX Note that this is not entirely correct. |
3402 |
|
we would have to match multibyte sequences |
3403 |
|
but this is not possible with the current |
3404 |
|
implementation. */ |
3405 |
|
for (ch = 1; ch < 256; ++ch) |
3406 |
|
/* XXX This test would have to be changed if we |
3407 |
|
would allow matching multibyte sequences. */ |
3408 |
|
if (table[ch] > 0) |
3409 |
|
{ |
3410 |
|
int32_t idx2 = table[ch]; |
3411 |
|
size_t len = weights[idx2]; |
3412 |
|
|
3413 |
|
/* Test whether the lenghts match. */ |
3414 |
|
if (weights[idx] == len) |
3415 |
|
{ |
3416 |
|
/* They do. New compare the bytes of |
3417 |
|
the weight. */ |
3418 |
|
size_t cnt = 0; |
3419 |
|
|
3420 |
|
while (cnt < len |
3421 |
|
&& (weights[idx + 1 + cnt] |
3422 |
|
== weights[idx2 + 1 + cnt])) |
3423 |
|
++cnt; |
3424 |
|
|
3425 |
|
if (cnt == len) |
3426 |
|
/* They match. Mark the character as |
3427 |
|
acceptable. */ |
3428 |
|
SET_LIST_BIT (ch); |
3429 |
|
} |
3430 |
|
} |
3431 |
|
} |
3432 |
|
# endif |
3433 |
|
had_char_class = true; |
3434 |
|
} |
3435 |
|
else |
3436 |
|
{ |
3437 |
|
c1++; |
3438 |
|
while (c1--) |
3439 |
|
PATUNFETCH; |
3440 |
|
SET_LIST_BIT ('['); |
3441 |
|
SET_LIST_BIT ('='); |
3442 |
|
range_start = '='; |
3443 |
|
had_char_class = false; |
3444 |
|
} |
3445 |
|
} |
3446 |
|
else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '.') |
3447 |
|
{ |
3448 |
|
unsigned char str[128]; /* Should be large enough. */ |
3449 |
|
# ifdef _LIBC |
3450 |
|
uint32_t nrules = |
3451 |
|
_NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); |
3452 |
|
# endif |
3453 |
|
|
3454 |
|
PATFETCH (c); |
3455 |
|
c1 = 0; |
3456 |
|
|
3457 |
|
/* If pattern is `[[.'. */ |
3458 |
|
if (p == pend) FREE_STACK_RETURN (REG_EBRACK); |
3459 |
|
|
3460 |
|
for (;;) |
3461 |
|
{ |
3462 |
|
PATFETCH (c); |
3463 |
|
if ((c == '.' && *p == ']') || p == pend) |
3464 |
|
break; |
3465 |
|
if (c1 < sizeof (str)) |
3466 |
|
str[c1++] = c; |
3467 |
|
else |
3468 |
|
/* This is in any case an invalid class name. */ |
3469 |
|
str[0] = '\0'; |
3470 |
|
} |
3471 |
|
str[c1] = '\0'; |
3472 |
|
|
3473 |
|
if (c == '.' && *p == ']' && str[0] != '\0') |
3474 |
|
{ |
3475 |
|
/* If we have no collation data we use the default |
3476 |
|
collation in which each character is the name |
3477 |
|
for its own class which contains only the one |
3478 |
|
character. It also means that ASCII is the |
3479 |
|
character set and therefore we cannot have character |
3480 |
|
with more than one byte in the multibyte |
3481 |
|
representation. */ |
3482 |
|
# ifdef _LIBC |
3483 |
|
if (nrules == 0) |
3484 |
|
# endif |
3485 |
|
{ |
3486 |
|
if (c1 != 1) |
3487 |
|
FREE_STACK_RETURN (REG_ECOLLATE); |
3488 |
|
|
3489 |
|
/* Throw away the ] at the end of the equivalence |
3490 |
|
class. */ |
3491 |
|
PATFETCH (c); |
3492 |
|
|
3493 |
|
/* Set the bit for the character. */ |
3494 |
|
SET_LIST_BIT (str[0]); |
3495 |
|
range_start = ((const unsigned char *) str)[0]; |
3496 |
|
} |
3497 |
|
# ifdef _LIBC |
3498 |
|
else |
3499 |
|
{ |
3500 |
|
/* Try to match the byte sequence in `str' against |
3501 |
|
those known to the collate implementation. |
3502 |
|
First find out whether the bytes in `str' are |
3503 |
|
actually from exactly one character. */ |
3504 |
|
int32_t table_size; |
3505 |
|
const int32_t *symb_table; |
3506 |
|
const unsigned char *extra; |
3507 |
|
int32_t idx; |
3508 |
|
int32_t elem; |
3509 |
|
int32_t second; |
3510 |
|
int32_t hash; |
3511 |
|
|
3512 |
|
table_size = |
3513 |
|
_NL_CURRENT_WORD (LC_COLLATE, |
3514 |
|
_NL_COLLATE_SYMB_HASH_SIZEMB); |
3515 |
|
symb_table = (const int32_t *) |
3516 |
|
_NL_CURRENT (LC_COLLATE, |
3517 |
|
_NL_COLLATE_SYMB_TABLEMB); |
3518 |
|
extra = (const unsigned char *) |
3519 |
|
_NL_CURRENT (LC_COLLATE, |
3520 |
|
_NL_COLLATE_SYMB_EXTRAMB); |
3521 |
|
|
3522 |
|
/* Locate the character in the hashing table. */ |
3523 |
|
hash = elem_hash (str, c1); |
3524 |
|
|
3525 |
|
idx = 0; |
3526 |
|
elem = hash % table_size; |
3527 |
|
second = hash % (table_size - 2); |
3528 |
|
while (symb_table[2 * elem] != 0) |
3529 |
|
{ |
3530 |
|
/* First compare the hashing value. */ |
3531 |
|
if (symb_table[2 * elem] == hash |
3532 |
|
&& c1 == extra[symb_table[2 * elem + 1]] |
3533 |
|
&& memcmp (str, |
3534 |
|
&extra[symb_table[2 * elem + 1] |
3535 |
|
+ 1], |
3536 |
|
c1) == 0) |
3537 |
|
{ |
3538 |
|
/* Yep, this is the entry. */ |
3539 |
|
idx = symb_table[2 * elem + 1]; |
3540 |
|
idx += 1 + extra[idx]; |
3541 |
|
break; |
3542 |
|
} |
3543 |
|
|
3544 |
|
/* Next entry. */ |
3545 |
|
elem += second; |
3546 |
|
} |
3547 |
|
|
3548 |
|
if (symb_table[2 * elem] == 0) |
3549 |
|
/* This is no valid character. */ |
3550 |
|
FREE_STACK_RETURN (REG_ECOLLATE); |
3551 |
|
|
3552 |
|
/* Throw away the ] at the end of the equivalence |
3553 |
|
class. */ |
3554 |
|
PATFETCH (c); |
3555 |
|
|
3556 |
|
/* Now add the multibyte character(s) we found |
3557 |
|
to the accept list. |
3558 |
|
|
3559 |
|
XXX Note that this is not entirely correct. |
3560 |
|
we would have to match multibyte sequences |
3561 |
|
but this is not possible with the current |
3562 |
|
implementation. Also, we have to match |
3563 |
|
collating symbols, which expand to more than |
3564 |
|
one file, as a whole and not allow the |
3565 |
|
individual bytes. */ |
3566 |
|
c1 = extra[idx++]; |
3567 |
|
if (c1 == 1) |
3568 |
|
range_start = extra[idx]; |
3569 |
|
while (c1-- > 0) |
3570 |
|
{ |
3571 |
|
SET_LIST_BIT (extra[idx]); |
3572 |
|
++idx; |
3573 |
|
} |
3574 |
|
} |
3575 |
|
# endif |
3576 |
|
had_char_class = false; |
3577 |
|
} |
3578 |
|
else |
3579 |
|
{ |
3580 |
|
c1++; |
3581 |
|
while (c1--) |
3582 |
|
PATUNFETCH; |
3583 |
|
SET_LIST_BIT ('['); |
3584 |
|
SET_LIST_BIT ('.'); |
3585 |
|
range_start = '.'; |
3586 |
|
had_char_class = false; |
3587 |
|
} |
3588 |
|
} |
3589 |
else |
else |
3590 |
{ |
{ |
3591 |
had_char_class = false; |
had_char_class = false; |
3592 |
SET_LIST_BIT (c); |
SET_LIST_BIT (c); |
3593 |
|
range_start = c; |
3594 |
} |
} |
3595 |
} |
} |
3596 |
|
|
3597 |
/* Discard any (non)matching list bytes that are all 0 at the |
/* Discard any (non)matching list bytes that are all 0 at the |
3598 |
end of the map. Decrease the map-length byte too. */ |
end of the map. Decrease the map-length byte too. */ |
3599 |
while ((int) b[-1] > 0 && b[b[-1] - 1] == 0) |
while ((int) b[-1] > 0 && b[b[-1] - 1] == 0) |
3600 |
b[-1]--; |
b[-1]--; |
3601 |
b += b[-1]; |
b += b[-1]; |
3602 |
|
#endif /* WCHAR */ |
3603 |
} |
} |
3604 |
break; |
break; |
3605 |
|
|
3658 |
regnum++; |
regnum++; |
3659 |
|
|
3660 |
if (COMPILE_STACK_FULL) |
if (COMPILE_STACK_FULL) |
3661 |
{ |
{ |
3662 |
RETALLOC (compile_stack.stack, compile_stack.size << 1, |
RETALLOC (compile_stack.stack, compile_stack.size << 1, |
3663 |
compile_stack_elt_t); |
compile_stack_elt_t); |
3664 |
if (compile_stack.stack == NULL) return REG_ESPACE; |
if (compile_stack.stack == NULL) return REG_ESPACE; |
3670 |
group. They are all relative offsets, so that if the |
group. They are all relative offsets, so that if the |
3671 |
whole pattern moves because of realloc, they will still |
whole pattern moves because of realloc, they will still |
3672 |
be valid. */ |
be valid. */ |
3673 |
COMPILE_STACK_TOP.begalt_offset = begalt - bufp->buffer; |
COMPILE_STACK_TOP.begalt_offset = begalt - COMPILED_BUFFER_VAR; |
3674 |
COMPILE_STACK_TOP.fixup_alt_jump |
COMPILE_STACK_TOP.fixup_alt_jump |
3675 |
= fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0; |
= fixup_alt_jump ? fixup_alt_jump - COMPILED_BUFFER_VAR + 1 : 0; |
3676 |
COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer; |
COMPILE_STACK_TOP.laststart_offset = b - COMPILED_BUFFER_VAR; |
3677 |
COMPILE_STACK_TOP.regnum = regnum; |
COMPILE_STACK_TOP.regnum = regnum; |
3678 |
|
|
3679 |
/* We will eventually replace the 0 with the number of |
/* We will eventually replace the 0 with the number of |
3682 |
represent in the compiled pattern. */ |
represent in the compiled pattern. */ |
3683 |
if (regnum <= MAX_REGNUM) |
if (regnum <= MAX_REGNUM) |
3684 |
{ |
{ |
3685 |
COMPILE_STACK_TOP.inner_group_offset = b - bufp->buffer + 2; |
COMPILE_STACK_TOP.inner_group_offset = b |
3686 |
|
- COMPILED_BUFFER_VAR + 2; |
3687 |
BUF_PUSH_3 (start_memory, regnum, 0); |
BUF_PUSH_3 (start_memory, regnum, 0); |
3688 |
} |
} |
3689 |
|
|
3690 |
compile_stack.avail++; |
compile_stack.avail++; |
3691 |
|
|
3692 |
fixup_alt_jump = 0; |
fixup_alt_jump = 0; |
3703 |
if (syntax & RE_NO_BK_PARENS) goto normal_backslash; |
if (syntax & RE_NO_BK_PARENS) goto normal_backslash; |
3704 |
|
|
3705 |
if (COMPILE_STACK_EMPTY) |
if (COMPILE_STACK_EMPTY) |
3706 |
if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD) |
{ |
3707 |
goto normal_backslash; |
if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD) |
3708 |
else |
goto normal_backslash; |
3709 |
FREE_STACK_RETURN (REG_ERPAREN); |
else |
3710 |
|
FREE_STACK_RETURN (REG_ERPAREN); |
3711 |
|
} |
3712 |
|
|
3713 |
handle_close: |
handle_close: |
3714 |
if (fixup_alt_jump) |
if (fixup_alt_jump) |
3717 |
`pop_failure_jump' to pop. See comments at |
`pop_failure_jump' to pop. See comments at |
3718 |
`push_dummy_failure' in `re_match_2'. */ |
`push_dummy_failure' in `re_match_2'. */ |
3719 |
BUF_PUSH (push_dummy_failure); |
BUF_PUSH (push_dummy_failure); |
3720 |
|
|
3721 |
/* We allocated space for this jump when we assigned |
/* We allocated space for this jump when we assigned |
3722 |
to `fixup_alt_jump', in the `handle_alt' case below. */ |
to `fixup_alt_jump', in the `handle_alt' case below. */ |
3723 |
STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1); |
STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1); |
3725 |
|
|
3726 |
/* See similar code for backslashed left paren above. */ |
/* See similar code for backslashed left paren above. */ |
3727 |
if (COMPILE_STACK_EMPTY) |
if (COMPILE_STACK_EMPTY) |
3728 |
if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD) |
{ |
3729 |
goto normal_char; |
if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD) |
3730 |
else |
goto normal_char; |
3731 |
FREE_STACK_RETURN (REG_ERPAREN); |
else |
3732 |
|
FREE_STACK_RETURN (REG_ERPAREN); |
3733 |
|
} |
3734 |
|
|
3735 |
/* Since we just checked for an empty stack above, this |
/* Since we just checked for an empty stack above, this |
3736 |
``can't happen''. */ |
``can't happen''. */ |
3741 |
as in `(ab)c(de)' -- the second group is #2. */ |
as in `(ab)c(de)' -- the second group is #2. */ |
3742 |
regnum_t this_group_regnum; |
regnum_t this_group_regnum; |
3743 |
|
|
3744 |
compile_stack.avail--; |
compile_stack.avail--; |
3745 |
begalt = bufp->buffer + COMPILE_STACK_TOP.begalt_offset; |
begalt = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.begalt_offset; |
3746 |
fixup_alt_jump |
fixup_alt_jump |
3747 |
= COMPILE_STACK_TOP.fixup_alt_jump |
= COMPILE_STACK_TOP.fixup_alt_jump |
3748 |
? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1 |
? COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.fixup_alt_jump - 1 |
3749 |
: 0; |
: 0; |
3750 |
laststart = bufp->buffer + COMPILE_STACK_TOP.laststart_offset; |
laststart = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.laststart_offset; |
3751 |
this_group_regnum = COMPILE_STACK_TOP.regnum; |
this_group_regnum = COMPILE_STACK_TOP.regnum; |
3752 |
/* If we've reached MAX_REGNUM groups, then this open |
/* If we've reached MAX_REGNUM groups, then this open |
3753 |
won't actually generate any code, so we'll have to |
won't actually generate any code, so we'll have to |
3758 |
groups were inside this one. */ |
groups were inside this one. */ |
3759 |
if (this_group_regnum <= MAX_REGNUM) |
if (this_group_regnum <= MAX_REGNUM) |
3760 |
{ |
{ |
3761 |
unsigned char *inner_group_loc |
UCHAR_T *inner_group_loc |
3762 |
= bufp->buffer + COMPILE_STACK_TOP.inner_group_offset; |
= COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.inner_group_offset; |
3763 |
|
|
3764 |
*inner_group_loc = regnum - this_group_regnum; |
*inner_group_loc = regnum - this_group_regnum; |
3765 |
BUF_PUSH_3 (stop_memory, this_group_regnum, |
BUF_PUSH_3 (stop_memory, this_group_regnum, |
3766 |
regnum - this_group_regnum); |
regnum - this_group_regnum); |
3778 |
|
|
3779 |
/* Insert before the previous alternative a jump which |
/* Insert before the previous alternative a jump which |
3780 |
jumps to this alternative if the former fails. */ |
jumps to this alternative if the former fails. */ |
3781 |
GET_BUFFER_SPACE (3); |
GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE); |
3782 |
INSERT_JUMP (on_failure_jump, begalt, b + 6); |
INSERT_JUMP (on_failure_jump, begalt, |
3783 |
|
b + 2 + 2 * OFFSET_ADDRESS_SIZE); |
3784 |
pending_exact = 0; |
pending_exact = 0; |
3785 |
b += 3; |
b += 1 + OFFSET_ADDRESS_SIZE; |
3786 |
|
|
3787 |
/* The alternative before this one has a jump after it |
/* The alternative before this one has a jump after it |
3788 |
which gets executed if it gets matched. Adjust that |
which gets executed if it gets matched. Adjust that |
3790 |
jump (put in below, which in turn will jump to the next |
jump (put in below, which in turn will jump to the next |
3791 |
(if any) alternative's such jump, etc.). The last such |
(if any) alternative's such jump, etc.). The last such |
3792 |
jump jumps to the correct final destination. A picture: |
jump jumps to the correct final destination. A picture: |
3793 |
_____ _____ |
_____ _____ |
3794 |
| | | | |
| | | | |
3795 |
| v | v |
| v | v |
3796 |
a | b | c |
a | b | c |
3797 |
|
|
3798 |
If we are at `b', then fixup_alt_jump right now points to a |
If we are at `b', then fixup_alt_jump right now points to a |
3799 |
three-byte space after `a'. We'll put in the jump, set |
three-byte space after `a'. We'll put in the jump, set |
3807 |
to be filled in later either by next alternative or |
to be filled in later either by next alternative or |
3808 |
when know we're at the end of a series of alternatives. */ |
when know we're at the end of a series of alternatives. */ |
3809 |
fixup_alt_jump = b; |
fixup_alt_jump = b; |
3810 |
GET_BUFFER_SPACE (3); |
GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE); |
3811 |
b += 3; |
b += 1 + OFFSET_ADDRESS_SIZE; |
3812 |
|
|
3813 |
laststart = 0; |
laststart = 0; |
3814 |
begalt = b; |
begalt = b; |
3815 |
break; |
break; |
3816 |
|
|
3817 |
|
|
3818 |
case '{': |
case '{': |
3819 |
/* If \{ is a literal. */ |
/* If \{ is a literal. */ |
3820 |
if (!(syntax & RE_INTERVALS) |
if (!(syntax & RE_INTERVALS) |
3821 |
/* If we're at `\{' and it's not the open-interval |
/* If we're at `\{' and it's not the open-interval |
3822 |
operator. */ |
operator. */ |
3823 |
|| ((syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES)) |
|| (syntax & RE_NO_BK_BRACES)) |
|
|| (p - 2 == pattern && p == pend)) |
|
3824 |
goto normal_backslash; |
goto normal_backslash; |
3825 |
|
|
3826 |
handle_interval: |
handle_interval: |
3830 |
/* At least (most) this many matches must be made. */ |
/* At least (most) this many matches must be made. */ |
3831 |
int lower_bound = -1, upper_bound = -1; |
int lower_bound = -1, upper_bound = -1; |
3832 |
|
|
3833 |
beg_interval = p - 1; |
/* Place in the uncompiled pattern (i.e., just after |
3834 |
|
the '{') to go back to if the interval is invalid. */ |
3835 |
|
const CHAR_T *beg_interval = p; |
3836 |
|
|
3837 |
if (p == pend) |
if (p == pend) |
3838 |
{ |
goto invalid_interval; |
|
if (syntax & RE_NO_BK_BRACES) |
|
|
goto unfetch_interval; |
|
|
else |
|
|
FREE_STACK_RETURN (REG_EBRACE); |
|
|
} |
|
3839 |
|
|
3840 |
GET_UNSIGNED_NUMBER (lower_bound); |
GET_UNSIGNED_NUMBER (lower_bound); |
3841 |
|
|
3842 |
if (c == ',') |
if (c == ',') |
3843 |
{ |
{ |
3844 |
GET_UNSIGNED_NUMBER (upper_bound); |
GET_UNSIGNED_NUMBER (upper_bound); |
3845 |
if (upper_bound < 0) upper_bound = RE_DUP_MAX; |
if (upper_bound < 0) |
3846 |
|
upper_bound = RE_DUP_MAX; |
3847 |
} |
} |
3848 |
else |
else |
3849 |
/* Interval such as `{1}' => match exactly once. */ |
/* Interval such as `{1}' => match exactly once. */ |
3850 |
upper_bound = lower_bound; |
upper_bound = lower_bound; |
3851 |
|
|
3852 |
if (lower_bound < 0 || upper_bound > RE_DUP_MAX |
if (! (0 <= lower_bound && lower_bound <= upper_bound)) |
3853 |
|| lower_bound > upper_bound) |
goto invalid_interval; |
|
{ |
|
|
if (syntax & RE_NO_BK_BRACES) |
|
|
goto unfetch_interval; |
|
|
else |
|
|
FREE_STACK_RETURN (REG_BADBR); |
|
|
} |
|
3854 |
|
|
3855 |
if (!(syntax & RE_NO_BK_BRACES)) |
if (!(syntax & RE_NO_BK_BRACES)) |
3856 |
{ |
{ |
3857 |
if (c != '\\') FREE_STACK_RETURN (REG_EBRACE); |
if (c != '\\' || p == pend) |
3858 |
|
goto invalid_interval; |
3859 |
PATFETCH (c); |
PATFETCH (c); |
3860 |
} |
} |
3861 |
|
|
3862 |
if (c != '}') |
if (c != '}') |
3863 |
{ |
goto invalid_interval; |
|
if (syntax & RE_NO_BK_BRACES) |
|
|
goto unfetch_interval; |
|
|
else |
|
|
FREE_STACK_RETURN (REG_BADBR); |
|
|
} |
|
|
|
|
|
/* We just parsed a valid interval. */ |
|
3864 |
|
|
3865 |
/* If it's invalid to have no preceding re. */ |
/* If it's invalid to have no preceding re. */ |
3866 |
if (!laststart) |
if (!laststart) |
3867 |
{ |
{ |
3868 |
if (syntax & RE_CONTEXT_INVALID_OPS) |
if (syntax & RE_CONTEXT_INVALID_OPS |
3869 |
|
&& !(syntax & RE_INVALID_INTERVAL_ORD)) |
3870 |
FREE_STACK_RETURN (REG_BADRPT); |
FREE_STACK_RETURN (REG_BADRPT); |
3871 |
else if (syntax & RE_CONTEXT_INDEP_OPS) |
else if (syntax & RE_CONTEXT_INDEP_OPS) |
3872 |
laststart = b; |
laststart = b; |
3874 |
goto unfetch_interval; |
goto unfetch_interval; |
3875 |
} |
} |
3876 |
|
|
3877 |
|
/* We just parsed a valid interval. */ |
3878 |
|
|
3879 |
|
if (RE_DUP_MAX < upper_bound) |
3880 |
|
FREE_STACK_RETURN (REG_BADBR); |
3881 |
|
|
3882 |
/* If the upper bound is zero, don't want to succeed at |
/* If the upper bound is zero, don't want to succeed at |
3883 |
all; jump from `laststart' to `b + 3', which will be |
all; jump from `laststart' to `b + 3', which will be |
3884 |
the end of the buffer after we insert the jump. */ |
the end of the buffer after we insert the jump. */ |
3885 |
|
/* ifdef WCHAR, 'b + 1 + OFFSET_ADDRESS_SIZE' |
3886 |
|
instead of 'b + 3'. */ |
3887 |
if (upper_bound == 0) |
if (upper_bound == 0) |
3888 |
{ |
{ |
3889 |
GET_BUFFER_SPACE (3); |
GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE); |
3890 |
INSERT_JUMP (jump, laststart, b + 3); |
INSERT_JUMP (jump, laststart, b + 1 |
3891 |
b += 3; |
+ OFFSET_ADDRESS_SIZE); |
3892 |
|
b += 1 + OFFSET_ADDRESS_SIZE; |
3893 |
} |
} |
3894 |
|
|
3895 |
/* Otherwise, we have a nontrivial interval. When |
/* Otherwise, we have a nontrivial interval. When |
3901 |
jump_n <succeed_n addr> <jump count> |
jump_n <succeed_n addr> <jump count> |
3902 |
(The upper bound and `jump_n' are omitted if |
(The upper bound and `jump_n' are omitted if |
3903 |
`upper_bound' is 1, though.) */ |
`upper_bound' is 1, though.) */ |
3904 |
else |
else |
3905 |
{ /* If the upper bound is > 1, we need to insert |
{ /* If the upper bound is > 1, we need to insert |
3906 |
more at the end of the loop. */ |
more at the end of the loop. */ |
3907 |
unsigned nbytes = 10 + (upper_bound > 1) * 10; |
unsigned nbytes = 2 + 4 * OFFSET_ADDRESS_SIZE + |
3908 |
|
(upper_bound > 1) * (2 + 4 * OFFSET_ADDRESS_SIZE); |
3909 |
|
|
3910 |
GET_BUFFER_SPACE (nbytes); |
GET_BUFFER_SPACE (nbytes); |
3911 |
|
|
3915 |
because `re_compile_fastmap' needs to know. |
because `re_compile_fastmap' needs to know. |
3916 |
Jump to the `jump_n' we might insert below. */ |
Jump to the `jump_n' we might insert below. */ |
3917 |
INSERT_JUMP2 (succeed_n, laststart, |
INSERT_JUMP2 (succeed_n, laststart, |
3918 |
b + 5 + (upper_bound > 1) * 5, |
b + 1 + 2 * OFFSET_ADDRESS_SIZE |
3919 |
lower_bound); |
+ (upper_bound > 1) * (1 + 2 * OFFSET_ADDRESS_SIZE) |
3920 |
b += 5; |
, lower_bound); |
3921 |
|
b += 1 + 2 * OFFSET_ADDRESS_SIZE; |
3922 |
|
|
3923 |
/* Code to initialize the lower bound. Insert |
/* Code to initialize the lower bound. Insert |
3924 |
before the `succeed_n'. The `5' is the last two |
before the `succeed_n'. The `5' is the last two |
3925 |
bytes of this `set_number_at', plus 3 bytes of |
bytes of this `set_number_at', plus 3 bytes of |
3926 |
the following `succeed_n'. */ |
the following `succeed_n'. */ |
3927 |
insert_op2 (set_number_at, laststart, 5, lower_bound, b); |
/* ifdef WCHAR, The '1+2*OFFSET_ADDRESS_SIZE' |
3928 |
b += 5; |
is the 'set_number_at', plus '1+OFFSET_ADDRESS_SIZE' |
3929 |
|
of the following `succeed_n'. */ |
3930 |
|
PREFIX(insert_op2) (set_number_at, laststart, 1 |
3931 |
|
+ 2 * OFFSET_ADDRESS_SIZE, lower_bound, b); |
3932 |
|
b += 1 + 2 * OFFSET_ADDRESS_SIZE; |
3933 |
|
|
3934 |
if (upper_bound > 1) |
if (upper_bound > 1) |
3935 |
{ /* More than one repetition is allowed, so |
{ /* More than one repetition is allowed, so |
3936 |
append a backward jump to the `succeed_n' |
append a backward jump to the `succeed_n' |
3937 |
that starts this interval. |
that starts this interval. |
3938 |
|
|
3939 |
When we've reached this during matching, |
When we've reached this during matching, |
3940 |
we'll have matched the interval once, so |
we'll have matched the interval once, so |
3941 |
jump back only `upper_bound - 1' times. */ |
jump back only `upper_bound - 1' times. */ |
3942 |
STORE_JUMP2 (jump_n, b, laststart + 5, |
STORE_JUMP2 (jump_n, b, laststart |
3943 |
|
+ 2 * OFFSET_ADDRESS_SIZE + 1, |
3944 |
upper_bound - 1); |
upper_bound - 1); |
3945 |
b += 5; |
b += 1 + 2 * OFFSET_ADDRESS_SIZE; |
3946 |
|
|
3947 |
/* The location we want to set is the second |
/* The location we want to set is the second |
3948 |
parameter of the `jump_n'; that is `b-2' as |
parameter of the `jump_n'; that is `b-2' as |
3954 |
so everything is getting moved up by 5. |
so everything is getting moved up by 5. |
3955 |
Conclusion: (b - 2) - (laststart + 3) + 5, |
Conclusion: (b - 2) - (laststart + 3) + 5, |
3956 |
i.e., b - laststart. |
i.e., b - laststart. |
3957 |
|
|
3958 |
We insert this at the beginning of the loop |
We insert this at the beginning of the loop |
3959 |
so that if we fail during matching, we'll |
so that if we fail during matching, we'll |
3960 |
reinitialize the bounds. */ |
reinitialize the bounds. */ |
3961 |
insert_op2 (set_number_at, laststart, b - laststart, |
PREFIX(insert_op2) (set_number_at, laststart, |
3962 |
upper_bound - 1, b); |
b - laststart, |
3963 |
b += 5; |
upper_bound - 1, b); |
3964 |
|
b += 1 + 2 * OFFSET_ADDRESS_SIZE; |
3965 |
} |
} |
3966 |
} |
} |
3967 |
pending_exact = 0; |
pending_exact = 0; |
3968 |
beg_interval = NULL; |
break; |
|
} |
|
|
break; |
|
3969 |
|
|
3970 |
unfetch_interval: |
invalid_interval: |
3971 |
/* If an invalid interval, match the characters as literals. */ |
if (!(syntax & RE_INVALID_INTERVAL_ORD)) |
3972 |
assert (beg_interval); |
FREE_STACK_RETURN (p == pend ? REG_EBRACE : REG_BADBR); |
3973 |
p = beg_interval; |
unfetch_interval: |
3974 |
beg_interval = NULL; |
/* Match the characters as literals. */ |
3975 |
|
p = beg_interval; |
3976 |
/* normal_char and normal_backslash need `c'. */ |
c = '{'; |
3977 |
PATFETCH (c); |
if (syntax & RE_NO_BK_BRACES) |
3978 |
|
goto normal_char; |
3979 |
if (!(syntax & RE_NO_BK_BRACES)) |
else |
3980 |
{ |
goto normal_backslash; |
3981 |
if (p > pattern && p[-1] == '\\') |
} |
|
goto normal_backslash; |
|
|
} |
|
|
goto normal_char; |
|
3982 |
|
|
3983 |
#ifdef emacs |
#ifdef emacs |
3984 |
/* There is no way to specify the before_dot and after_dot |
/* There is no way to specify the before_dot and after_dot |
3987 |
BUF_PUSH (at_dot); |
BUF_PUSH (at_dot); |
3988 |
break; |
break; |
3989 |
|
|
3990 |
case 's': |
case 's': |
3991 |
laststart = b; |
laststart = b; |
3992 |
PATFETCH (c); |
PATFETCH (c); |
3993 |
BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]); |
BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]); |
4002 |
|
|
4003 |
|
|
4004 |
case 'w': |
case 'w': |
4005 |
|
if (syntax & RE_NO_GNU_OPS) |
4006 |
|
goto normal_char; |
4007 |
laststart = b; |
laststart = b; |
4008 |
BUF_PUSH (wordchar); |
BUF_PUSH (wordchar); |
4009 |
break; |
break; |
4010 |
|
|
4011 |
|
|
4012 |
case 'W': |
case 'W': |
4013 |
|
if (syntax & RE_NO_GNU_OPS) |
4014 |
|
goto normal_char; |
4015 |
laststart = b; |
laststart = b; |
4016 |
BUF_PUSH (notwordchar); |
BUF_PUSH (notwordchar); |
4017 |
break; |
break; |
4018 |
|
|
4019 |
|
|
4020 |
case '<': |
case '<': |
4021 |
|
if (syntax & RE_NO_GNU_OPS) |
4022 |
|
goto normal_char; |
4023 |
BUF_PUSH (wordbeg); |
BUF_PUSH (wordbeg); |
4024 |
break; |
break; |
4025 |
|
|
4026 |
case '>': |
case '>': |
4027 |
|
if (syntax & RE_NO_GNU_OPS) |
4028 |
|
goto normal_char; |
4029 |
BUF_PUSH (wordend); |
BUF_PUSH (wordend); |
4030 |
break; |
break; |
4031 |
|
|
4032 |
case 'b': |
case 'b': |
4033 |
|
if (syntax & RE_NO_GNU_OPS) |
4034 |
|
goto normal_char; |
4035 |
BUF_PUSH (wordbound); |
BUF_PUSH (wordbound); |
4036 |
break; |
break; |
4037 |
|
|
4038 |
case 'B': |
case 'B': |
4039 |
|
if (syntax & RE_NO_GNU_OPS) |
4040 |
|
goto normal_char; |
4041 |
BUF_PUSH (notwordbound); |
BUF_PUSH (notwordbound); |
4042 |
break; |
break; |
4043 |
|
|
4044 |
case '`': |
case '`': |
4045 |
|
if (syntax & RE_NO_GNU_OPS) |
4046 |
|
goto normal_char; |
4047 |
BUF_PUSH (begbuf); |
BUF_PUSH (begbuf); |
4048 |
break; |
break; |
4049 |
|
|
4050 |
case '\'': |
case '\'': |
4051 |
|
if (syntax & RE_NO_GNU_OPS) |
4052 |
|
goto normal_char; |
4053 |
BUF_PUSH (endbuf); |
BUF_PUSH (endbuf); |
4054 |
break; |
break; |
4055 |
|
|
4064 |
FREE_STACK_RETURN (REG_ESUBREG); |
FREE_STACK_RETURN (REG_ESUBREG); |
4065 |
|
|
4066 |
/* Can't back reference to a subexpression if inside of it. */ |
/* Can't back reference to a subexpression if inside of it. */ |
4067 |
if (group_in_compile_stack (compile_stack, c1)) |
if (group_in_compile_stack (compile_stack, (regnum_t) c1)) |
4068 |
goto normal_char; |
goto normal_char; |
4069 |
|
|
4070 |
laststart = b; |
laststart = b; |
4094 |
/* Expects the character in `c'. */ |
/* Expects the character in `c'. */ |
4095 |
normal_char: |
normal_char: |
4096 |
/* If no exactn currently being built. */ |
/* If no exactn currently being built. */ |
4097 |
if (!pending_exact |
if (!pending_exact |
4098 |
|
#ifdef WCHAR |
4099 |
|
/* If last exactn handle binary(or character) and |
4100 |
|
new exactn handle character(or binary). */ |
4101 |
|
|| is_exactn_bin != is_binary[p - 1 - pattern] |
4102 |
|
#endif /* WCHAR */ |
4103 |
|
|
4104 |
/* If last exactn not at current position. */ |
/* If last exactn not at current position. */ |
4105 |
|| pending_exact + *pending_exact + 1 != b |
|| pending_exact + *pending_exact + 1 != b |
4106 |
|
|
4107 |
/* We have only one byte following the exactn for the count. */ |
/* We have only one byte following the exactn for the count. */ |
4108 |
|| *pending_exact == (1 << BYTEWIDTH) - 1 |
|| *pending_exact == (1 << BYTEWIDTH) - 1 |
4109 |
|
|
4118 |
: (p[0] == '\\' && p[1] == '{')))) |
: (p[0] == '\\' && p[1] == '{')))) |
4119 |
{ |
{ |
4120 |
/* Start building a new exactn. */ |
/* Start building a new exactn. */ |
4121 |
|
|
4122 |
laststart = b; |
laststart = b; |
4123 |
|
|
4124 |
|
#ifdef WCHAR |
4125 |
|
/* Is this exactn binary data or character? */ |
4126 |
|
is_exactn_bin = is_binary[p - 1 - pattern]; |
4127 |
|
if (is_exactn_bin) |
4128 |
|
BUF_PUSH_2 (exactn_bin, 0); |
4129 |
|
else |
4130 |
|
BUF_PUSH_2 (exactn, 0); |
4131 |
|
#else |
4132 |
BUF_PUSH_2 (exactn, 0); |
BUF_PUSH_2 (exactn, 0); |
4133 |
|
#endif /* WCHAR */ |
4134 |
pending_exact = b - 1; |
pending_exact = b - 1; |
4135 |
} |
} |
4136 |
|
|
4137 |
BUF_PUSH (c); |
BUF_PUSH (c); |
4138 |
(*pending_exact)++; |
(*pending_exact)++; |
4139 |
break; |
break; |
4140 |
} /* switch (c) */ |
} /* switch (c) */ |
4141 |
} /* while p != pend */ |
} /* while p != pend */ |
4142 |
|
|
4143 |
|
|
4144 |
/* Through the pattern now. */ |
/* Through the pattern now. */ |
4145 |
|
|
4146 |
if (fixup_alt_jump) |
if (fixup_alt_jump) |
4147 |
STORE_JUMP (jump_past_alt, fixup_alt_jump, b); |
STORE_JUMP (jump_past_alt, fixup_alt_jump, b); |
4148 |
|
|
4149 |
if (!COMPILE_STACK_EMPTY) |
if (!COMPILE_STACK_EMPTY) |
4150 |
FREE_STACK_RETURN (REG_EPAREN); |
FREE_STACK_RETURN (REG_EPAREN); |
4151 |
|
|
4152 |
|
/* If we don't want backtracking, force success |
4153 |
|
the first time we reach the end of the compiled pattern. */ |
4154 |
|
if (syntax & RE_NO_POSIX_BACKTRACKING) |
4155 |
|
BUF_PUSH (succeed); |
4156 |
|
|
4157 |
|
#ifdef WCHAR |
4158 |
|
free (pattern); |
4159 |
|
free (mbs_offset); |
4160 |
|
free (is_binary); |
4161 |
|
#endif |
4162 |
free (compile_stack.stack); |
free (compile_stack.stack); |
4163 |
|
|
4164 |
/* We have succeeded; set the length of the buffer. */ |
/* We have succeeded; set the length of the buffer. */ |
4165 |
|
#ifdef WCHAR |
4166 |
|
bufp->used = (uintptr_t) b - (uintptr_t) COMPILED_BUFFER_VAR; |
4167 |
|
#else |
4168 |
bufp->used = b - bufp->buffer; |
bufp->used = b - bufp->buffer; |
4169 |
|
#endif |
4170 |
|
|
4171 |
#ifdef DEBUG |
#ifdef DEBUG |
4172 |
if (debug) |
if (debug) |
4173 |
{ |
{ |
4174 |
DEBUG_PRINT1 ("\nCompiled pattern: \n"); |
DEBUG_PRINT1 ("\nCompiled pattern: \n"); |
4175 |
print_compiled_pattern (bufp); |
PREFIX(print_compiled_pattern) (bufp); |
4176 |
} |
} |
4177 |
#endif /* DEBUG */ |
#endif /* DEBUG */ |
4178 |
|
|
4190 |
{ |
{ |
4191 |
fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS); |
fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS); |
4192 |
|
|
4193 |
#ifdef emacs |
# ifdef emacs |
4194 |
if (! fail_stack.stack) |
if (! fail_stack.stack) |
4195 |
fail_stack.stack |
fail_stack.stack |
4196 |
= (fail_stack_elt_t *) xmalloc (fail_stack.size |
= (PREFIX(fail_stack_elt_t) *) xmalloc (fail_stack.size |
4197 |
* sizeof (fail_stack_elt_t)); |
* sizeof (PREFIX(fail_stack_elt_t))); |
4198 |
else |
else |
4199 |
fail_stack.stack |
fail_stack.stack |
4200 |
= (fail_stack_elt_t *) xrealloc (fail_stack.stack, |
= (PREFIX(fail_stack_elt_t) *) xrealloc (fail_stack.stack, |
4201 |
(fail_stack.size |
(fail_stack.size |
4202 |
* sizeof (fail_stack_elt_t))); |
* sizeof (PREFIX(fail_stack_elt_t)))); |
4203 |
#else /* not emacs */ |
# else /* not emacs */ |
4204 |
if (! fail_stack.stack) |
if (! fail_stack.stack) |
4205 |
fail_stack.stack |
fail_stack.stack |
4206 |
= (fail_stack_elt_t *) malloc (fail_stack.size |
= malloc (fail_stack.size * sizeof (PREFIX(fail_stack_elt_t))); |
|
* sizeof (fail_stack_elt_t)); |
|
4207 |
else |
else |
4208 |
fail_stack.stack |
fail_stack.stack |
4209 |
= (fail_stack_elt_t *) realloc (fail_stack.stack, |
= realloc (fail_stack.stack, |
4210 |
(fail_stack.size |
fail_stack.size * sizeof (PREFIX(fail_stack_elt_t))); |
4211 |
* sizeof (fail_stack_elt_t))); |
# endif /* not emacs */ |
|
#endif /* not emacs */ |
|
4212 |
} |
} |
4213 |
|
|
4214 |
/* Initialize some other variables the matcher uses. */ |
PREFIX(regex_grow_registers) (num_regs); |
|
RETALLOC_IF (regstart, num_regs, const char *); |
|
|
RETALLOC_IF (regend, num_regs, const char *); |
|
|
RETALLOC_IF (old_regstart, num_regs, const char *); |
|
|
RETALLOC_IF (old_regend, num_regs, const char *); |
|
|
RETALLOC_IF (best_regstart, num_regs, const char *); |
|
|
RETALLOC_IF (best_regend, num_regs, const char *); |
|
|
RETALLOC_IF (reg_info, num_regs, register_info_type); |
|
|
RETALLOC_IF (reg_dummy, num_regs, const char *); |
|
|
RETALLOC_IF (reg_info_dummy, num_regs, register_info_type); |
|
4215 |
} |
} |
4216 |
#endif |
#endif /* not MATCH_MAY_ALLOCATE */ |
4217 |
|
|
4218 |
return REG_NOERROR; |
return REG_NOERROR; |
4219 |
} /* regex_compile */ |
} /* regex_compile */ |
4220 |
|
|
4221 |
/* Subroutines for `regex_compile'. */ |
/* Subroutines for `regex_compile'. */ |
4222 |
|
|
4223 |
/* Store OP at LOC followed by two-byte integer parameter ARG. */ |
/* Store OP at LOC followed by two-byte integer parameter ARG. */ |
4224 |
|
/* ifdef WCHAR, integer parameter is 1 wchar_t. */ |
4225 |
|
|
4226 |
static void |
static void |
4227 |
store_op1 (op, loc, arg) |
PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg) |
|
re_opcode_t op; |
|
|
unsigned char *loc; |
|
|
int arg; |
|
4228 |
{ |
{ |
4229 |
*loc = (unsigned char) op; |
*loc = (UCHAR_T) op; |
4230 |
STORE_NUMBER (loc + 1, arg); |
STORE_NUMBER (loc + 1, arg); |
4231 |
} |
} |
4232 |
|
|
4233 |
|
|
4234 |
/* Like `store_op1', but for two two-byte parameters ARG1 and ARG2. */ |
/* Like `store_op1', but for two two-byte parameters ARG1 and ARG2. */ |
4235 |
|
/* ifdef WCHAR, integer parameter is 1 wchar_t. */ |
4236 |
|
|
4237 |
static void |
static void |
4238 |
store_op2 (op, loc, arg1, arg2) |
PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc, int arg1, int arg2) |
|
re_opcode_t op; |
|
|
unsigned char *loc; |
|
|
int arg1, arg2; |
|
4239 |
{ |
{ |
4240 |
*loc = (unsigned char) op; |
*loc = (UCHAR_T) op; |
4241 |
STORE_NUMBER (loc + 1, arg1); |
STORE_NUMBER (loc + 1, arg1); |
4242 |
STORE_NUMBER (loc + 3, arg2); |
STORE_NUMBER (loc + 1 + OFFSET_ADDRESS_SIZE, arg2); |
4243 |
} |
} |
4244 |
|
|
4245 |
|
|
4246 |
/* Copy the bytes from LOC to END to open up three bytes of space at LOC |
/* Copy the bytes from LOC to END to open up three bytes of space at LOC |
4247 |
for OP followed by two-byte integer parameter ARG. */ |
for OP followed by two-byte integer parameter ARG. */ |
4248 |
|
/* ifdef WCHAR, integer parameter is 1 wchar_t. */ |
4249 |
|
|
4250 |
static void |
static void |
4251 |
insert_op1 (op, loc, arg, end) |
PREFIX(insert_op1) (re_opcode_t op, UCHAR_T *loc, int arg, UCHAR_T *end) |
|
re_opcode_t op; |
|
|
unsigned char *loc; |
|
|
int arg; |
|
|
unsigned char *end; |
|
4252 |
{ |
{ |
4253 |
register unsigned char *pfrom = end; |
register UCHAR_T *pfrom = end; |
4254 |
register unsigned char *pto = end + 3; |
register UCHAR_T *pto = end + 1 + OFFSET_ADDRESS_SIZE; |
4255 |
|
|
4256 |
while (pfrom != loc) |
while (pfrom != loc) |
4257 |
*--pto = *--pfrom; |
*--pto = *--pfrom; |
4258 |
|
|
4259 |
store_op1 (op, loc, arg); |
PREFIX(store_op1) (op, loc, arg); |
4260 |
} |
} |
4261 |
|
|
4262 |
|
|
4263 |
/* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2. */ |
/* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2. */ |
4264 |
|
/* ifdef WCHAR, integer parameter is 1 wchar_t. */ |
4265 |
|
|
4266 |
static void |
static void |
4267 |
insert_op2 (op, loc, arg1, arg2, end) |
PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc, int arg1, int arg2, |
4268 |
re_opcode_t op; |
UCHAR_T *end) |
|
unsigned char *loc; |
|
|
int arg1, arg2; |
|
|
unsigned char *end; |
|
4269 |
{ |
{ |
4270 |
register unsigned char *pfrom = end; |
register UCHAR_T *pfrom = end; |
4271 |
register unsigned char *pto = end + 5; |
register UCHAR_T *pto = end + 1 + 2 * OFFSET_ADDRESS_SIZE; |
4272 |
|
|
4273 |
while (pfrom != loc) |
while (pfrom != loc) |
4274 |
*--pto = *--pfrom; |
*--pto = *--pfrom; |
4275 |
|
|
4276 |
store_op2 (op, loc, arg1, arg2); |
PREFIX(store_op2) (op, loc, arg1, arg2); |
4277 |
} |
} |
4278 |
|
|
4279 |
|
|
4282 |
least one character before the ^. */ |
least one character before the ^. */ |
4283 |
|
|
4284 |
static boolean |
static boolean |
4285 |
at_begline_loc_p (pattern, p, syntax) |
PREFIX(at_begline_loc_p) (const CHAR_T *pattern, const CHAR_T *p, |
4286 |
const char *pattern, *p; |
reg_syntax_t syntax) |
|
reg_syntax_t syntax; |
|
4287 |
{ |
{ |
4288 |
const char *prev = p - 2; |
const CHAR_T *prev = p - 2; |
4289 |
boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\'; |
boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\'; |
4290 |
|
|
4291 |
return |
return |
4292 |
/* After a subexpression? */ |
/* After a subexpression? */ |
4293 |
(*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash)) |
(*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash)) |
4300 |
at least one character after the $, i.e., `P < PEND'. */ |
at least one character after the $, i.e., `P < PEND'. */ |
4301 |
|
|
4302 |
static boolean |
static boolean |
4303 |
at_endline_loc_p (p, pend, syntax) |
PREFIX(at_endline_loc_p) (const CHAR_T *p, const CHAR_T *pend, |
4304 |
const char *p, *pend; |
reg_syntax_t syntax) |
|
int syntax; |
|
4305 |
{ |
{ |
4306 |
const char *next = p; |
const CHAR_T *next = p; |
4307 |
boolean next_backslash = *next == '\\'; |
boolean next_backslash = *next == '\\'; |
4308 |
const char *next_next = p + 1 < pend ? p + 1 : NULL; |
const CHAR_T *next_next = p + 1 < pend ? p + 1 : 0; |
4309 |
|
|
4310 |
return |
return |
4311 |
/* Before a subexpression? */ |
/* Before a subexpression? */ |
4312 |
(syntax & RE_NO_BK_PARENS ? *next == ')' |
(syntax & RE_NO_BK_PARENS ? *next == ')' |
4316 |
: next_backslash && next_next && *next_next == '|'); |
: next_backslash && next_next && *next_next == '|'); |
4317 |
} |
} |
4318 |
|
|
4319 |
|
#else /* not INSIDE_RECURSION */ |
4320 |
|
|
4321 |
/* Returns true if REGNUM is in one of COMPILE_STACK's elements and |
/* Returns true if REGNUM is in one of COMPILE_STACK's elements and |
4322 |
false if it's not. */ |
false if it's not. */ |
4323 |
|
|
4324 |
static boolean |
static boolean |
4325 |
group_in_compile_stack (compile_stack, regnum) |
group_in_compile_stack (compile_stack_type compile_stack, |
4326 |
compile_stack_type compile_stack; |
regnum_t regnum) |
|
regnum_t regnum; |
|
4327 |
{ |
{ |
4328 |
int this_element; |
int this_element; |
4329 |
|
|
4330 |
for (this_element = compile_stack.avail - 1; |
for (this_element = compile_stack.avail - 1; |
4331 |
this_element >= 0; |
this_element >= 0; |
4332 |
this_element--) |
this_element--) |
4333 |
if (compile_stack.stack[this_element].regnum == regnum) |
if (compile_stack.stack[this_element].regnum == regnum) |
4334 |
return true; |
return true; |
4335 |
|
|
4336 |
return false; |
return false; |
4337 |
} |
} |
4338 |
|
#endif /* not INSIDE_RECURSION */ |
4339 |
|
|
4340 |
|
#ifdef INSIDE_RECURSION |
4341 |
|
|
4342 |
|
#ifdef WCHAR |
4343 |
|
/* This insert space, which size is "num", into the pattern at "loc". |
4344 |
|
"end" must point the end of the allocated buffer. */ |
4345 |
|
static void |
4346 |
|
insert_space (int num, CHAR_T *loc, CHAR_T *end) |
4347 |
|
{ |
4348 |
|
register CHAR_T *pto = end; |
4349 |
|
register CHAR_T *pfrom = end - num; |
4350 |
|
|
4351 |
|
while (pfrom >= loc) |
4352 |
|
*pto-- = *pfrom--; |
4353 |
|
} |
4354 |
|
#endif /* WCHAR */ |
4355 |
|
|
4356 |
|
#ifdef WCHAR |
4357 |
|
static reg_errcode_t |
4358 |
|
wcs_compile_range (CHAR_T range_start_char, |
4359 |
|
const CHAR_T **p_ptr, const CHAR_T *pend, |
4360 |
|
RE_TRANSLATE_TYPE translate, reg_syntax_t syntax, |
4361 |
|
CHAR_T *b, CHAR_T *char_set) |
4362 |
|
{ |
4363 |
|
const CHAR_T *p = *p_ptr; |
4364 |
|
CHAR_T range_start, range_end; |
4365 |
|
reg_errcode_t ret; |
4366 |
|
# ifdef _LIBC |
4367 |
|
uint32_t nrules; |
4368 |
|
uint32_t start_val, end_val; |
4369 |
|
# endif |
4370 |
|
if (p == pend) |
4371 |
|
return REG_ERANGE; |
4372 |
|
|
4373 |
|
# ifdef _LIBC |
4374 |
|
nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); |
4375 |
|
if (nrules != 0) |
4376 |
|
{ |
4377 |
|
const char *collseq = (const char *) _NL_CURRENT(LC_COLLATE, |
4378 |
|
_NL_COLLATE_COLLSEQWC); |
4379 |
|
const unsigned char *extra = (const unsigned char *) |
4380 |
|
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB); |
4381 |
|
|
4382 |
|
if (range_start_char < -1) |
4383 |
|
{ |
4384 |
|
/* range_start is a collating symbol. */ |
4385 |
|
int32_t *wextra; |
4386 |
|
/* Retreive the index and get collation sequence value. */ |
4387 |
|
wextra = (int32_t*)(extra + char_set[-range_start_char]); |
4388 |
|
start_val = wextra[1 + *wextra]; |
4389 |
|
} |
4390 |
|
else |
4391 |
|
start_val = collseq_table_lookup(collseq, TRANSLATE(range_start_char)); |
4392 |
|
|
4393 |
|
end_val = collseq_table_lookup (collseq, TRANSLATE (p[0])); |
4394 |
|
|
4395 |
|
/* Report an error if the range is empty and the syntax prohibits |
4396 |
|
this. */ |
4397 |
|
ret = ((syntax & RE_NO_EMPTY_RANGES) |
4398 |
|
&& (start_val > end_val))? REG_ERANGE : REG_NOERROR; |
4399 |
|
|
4400 |
|
/* Insert space to the end of the char_ranges. */ |
4401 |
|
insert_space(2, b - char_set[5] - 2, b - 1); |
4402 |
|
*(b - char_set[5] - 2) = (wchar_t)start_val; |
4403 |
|
*(b - char_set[5] - 1) = (wchar_t)end_val; |
4404 |
|
char_set[4]++; /* ranges_index */ |
4405 |
|
} |
4406 |
|
else |
4407 |
|
# endif |
4408 |
|
{ |
4409 |
|
range_start = (range_start_char >= 0)? TRANSLATE (range_start_char): |
4410 |
|
range_start_char; |
4411 |
|
range_end = TRANSLATE (p[0]); |
4412 |
|
/* Report an error if the range is empty and the syntax prohibits |
4413 |
|
this. */ |
4414 |
|
ret = ((syntax & RE_NO_EMPTY_RANGES) |
4415 |
|
&& (range_start > range_end))? REG_ERANGE : REG_NOERROR; |
4416 |
|
|
4417 |
|
/* Insert space to the end of the char_ranges. */ |
4418 |
|
insert_space(2, b - char_set[5] - 2, b - 1); |
4419 |
|
*(b - char_set[5] - 2) = range_start; |
4420 |
|
*(b - char_set[5] - 1) = range_end; |
4421 |
|
char_set[4]++; /* ranges_index */ |
4422 |
|
} |
4423 |
|
/* Have to increment the pointer into the pattern string, so the |
4424 |
|
caller isn't still at the ending character. */ |
4425 |
|
(*p_ptr)++; |
4426 |
|
|
4427 |
|
return ret; |
4428 |
|
} |
4429 |
|
#else /* BYTE */ |
4430 |
/* Read the ending character of a range (in a bracket expression) from the |
/* Read the ending character of a range (in a bracket expression) from the |
4431 |
uncompiled pattern *P_PTR (which ends at PEND). We assume the |
uncompiled pattern *P_PTR (which ends at PEND). We assume the |
4432 |
starting character is in `P[-2]'. (`P[-1]' is the character `-'.) |
starting character is in `P[-2]'. (`P[-1]' is the character `-'.) |
4433 |
Then we set the translation of all bits between the starting and |
Then we set the translation of all bits between the starting and |
4434 |
ending characters (inclusive) in the compiled pattern B. |
ending characters (inclusive) in the compiled pattern B. |
4435 |
|
|
4436 |
Return an error code. |
Return an error code. |
4437 |
|
|
4438 |
We use these short variable names so we can use the same macros as |
We use these short variable names so we can use the same macros as |
4439 |
`regex_compile' itself. */ |
`regex_compile' itself. */ |
4440 |
|
|
4441 |
static reg_errcode_t |
static reg_errcode_t |
4442 |
compile_range (p_ptr, pend, translate, syntax, b) |
byte_compile_range (unsigned int range_start_char, |
4443 |
const char **p_ptr, *pend; |
const char **p_ptr, const char *pend, |
4444 |
char *translate; |
RE_TRANSLATE_TYPE translate, reg_syntax_t syntax, |
4445 |
reg_syntax_t syntax; |
unsigned char *b) |
|
unsigned char *b; |
|
4446 |
{ |
{ |
4447 |
unsigned this_char; |
unsigned this_char; |
|
|
|
4448 |
const char *p = *p_ptr; |
const char *p = *p_ptr; |
4449 |
int range_start, range_end; |
reg_errcode_t ret; |
4450 |
|
# if _LIBC |
4451 |
|
const unsigned char *collseq; |
4452 |
|
unsigned int start_colseq; |
4453 |
|
unsigned int end_colseq; |
4454 |
|
# else |
4455 |
|
unsigned end_char; |
4456 |
|
# endif |
4457 |
|
|
4458 |
if (p == pend) |
if (p == pend) |
4459 |
return REG_ERANGE; |
return REG_ERANGE; |
4460 |
|
|
|
/* Even though the pattern is a signed `char *', we need to fetch |
|
|
with unsigned char *'s; if the high bit of the pattern character |
|
|
is set, the range endpoints will be negative if we fetch using a |
|
|
signed char *. |
|
|
|
|
|
We also want to fetch the endpoints without translating them; the |
|
|
appropriate translation is done in the bit-setting loop below. */ |
|
|
/* The SVR4 compiler on the 3B2 had trouble with unsigned const char *. */ |
|
|
range_start = ((const unsigned char *) p)[-2]; |
|
|
range_end = ((const unsigned char *) p)[0]; |
|
|
|
|
4461 |
/* Have to increment the pointer into the pattern string, so the |
/* Have to increment the pointer into the pattern string, so the |
4462 |
caller isn't still at the ending character. */ |
caller isn't still at the ending character. */ |
4463 |
(*p_ptr)++; |
(*p_ptr)++; |
4464 |
|
|
4465 |
/* If the start is after the end, the range is empty. */ |
/* Report an error if the range is empty and the syntax prohibits this. */ |
4466 |
if (range_start > range_end) |
ret = syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR; |
4467 |
return syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR; |
|
4468 |
|
# if _LIBC |
4469 |
|
collseq = (const unsigned char *) _NL_CURRENT (LC_COLLATE, |
4470 |
|
_NL_COLLATE_COLLSEQMB); |
4471 |
|
|
4472 |
|
start_colseq = collseq[(unsigned char) TRANSLATE (range_start_char)]; |
4473 |
|
end_colseq = collseq[(unsigned char) TRANSLATE (p[0])]; |
4474 |
|
for (this_char = 0; this_char <= (unsigned char) -1; ++this_char) |
4475 |
|
{ |
4476 |
|
unsigned int this_colseq = collseq[(unsigned char) TRANSLATE (this_char)]; |
4477 |
|
|
4478 |
|
if (start_colseq <= this_colseq && this_colseq <= end_colseq) |
4479 |
|
{ |
4480 |
|
SET_LIST_BIT (TRANSLATE (this_char)); |
4481 |
|
ret = REG_NOERROR; |
4482 |
|
} |
4483 |
|
} |
4484 |
|
# else |
4485 |
/* Here we see why `this_char' has to be larger than an `unsigned |
/* Here we see why `this_char' has to be larger than an `unsigned |
4486 |
char' -- the range is inclusive, so if `range_end' == 0xff |
char' -- we would otherwise go into an infinite loop, since all |
4487 |
(assuming 8-bit characters), we would otherwise go into an infinite |
characters <= 0xff. */ |
4488 |
loop, since all characters <= 0xff. */ |
range_start_char = TRANSLATE (range_start_char); |
4489 |
for (this_char = range_start; this_char <= range_end; this_char++) |
/* TRANSLATE(p[0]) is casted to char (not unsigned char) in TRANSLATE, |
4490 |
|
and some compilers cast it to int implicitly, so following for_loop |
4491 |
|
may fall to (almost) infinite loop. |
4492 |
|
e.g. If translate[p[0]] = 0xff, end_char may equals to 0xffffffff. |
4493 |
|
To avoid this, we cast p[0] to unsigned int and truncate it. */ |
4494 |
|
end_char = ((unsigned)TRANSLATE(p[0]) & ((1 << BYTEWIDTH) - 1)); |
4495 |
|
|
4496 |
|
for (this_char = range_start_char; this_char <= end_char; ++this_char) |
4497 |
{ |
{ |
4498 |
SET_LIST_BIT (TRANSLATE (this_char)); |
SET_LIST_BIT (TRANSLATE (this_char)); |
4499 |
|
ret = REG_NOERROR; |
4500 |
} |
} |
4501 |
|
# endif |
4502 |
return REG_NOERROR; |
|
4503 |
|
return ret; |
4504 |
} |
} |
4505 |
|
#endif /* WCHAR */ |
4506 |
|
|
4507 |
/* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in |
/* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in |
4508 |
BUFP. A fastmap records which of the (1 << BYTEWIDTH) possible |
BUFP. A fastmap records which of the (1 << BYTEWIDTH) possible |
4511 |
|
|
4512 |
The caller must supply the address of a (1 << BYTEWIDTH)-byte data |
The caller must supply the address of a (1 << BYTEWIDTH)-byte data |
4513 |
area as BUFP->fastmap. |
area as BUFP->fastmap. |
4514 |
|
|
4515 |
We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in |
We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in |
4516 |
the pattern buffer. |
the pattern buffer. |
4517 |
|
|
4518 |
Returns 0 if we succeed, -2 if an internal error. */ |
Returns 0 if we succeed, -2 if an internal error. */ |
4519 |
|
|
4520 |
int |
#ifdef WCHAR |
4521 |
re_compile_fastmap (bufp) |
/* local function for re_compile_fastmap. |
4522 |
struct re_pattern_buffer *bufp; |
truncate wchar_t character to char. */ |
4523 |
|
|
4524 |
|
static unsigned char |
4525 |
|
truncate_wchar (CHAR_T c) |
4526 |
|
{ |
4527 |
|
unsigned char buf[MB_CUR_MAX]; |
4528 |
|
mbstate_t state; |
4529 |
|
int retval; |
4530 |
|
memset (&state, '\0', sizeof (state)); |
4531 |
|
retval = wcrtomb (buf, c, &state); |
4532 |
|
return retval > 0 ? buf[0] : (unsigned char) c; |
4533 |
|
} |
4534 |
|
#endif /* WCHAR */ |
4535 |
|
|
4536 |
|
static int |
4537 |
|
PREFIX(re_compile_fastmap) (struct re_pattern_buffer *bufp) |
4538 |
{ |
{ |
4539 |
int j, k; |
int j, k; |
4540 |
#ifdef MATCH_MAY_ALLOCATE |
#ifdef MATCH_MAY_ALLOCATE |
4541 |
fail_stack_type fail_stack; |
PREFIX(fail_stack_type) fail_stack; |
4542 |
#endif |
#endif |
4543 |
#ifndef REGEX_MALLOC |
#ifndef REGEX_MALLOC |
4544 |
char *destination; |
char *destination; |
4545 |
#endif |
#endif |
4546 |
/* We don't push any register information onto the failure stack. */ |
|
|
unsigned num_regs = 0; |
|
|
|
|
4547 |
register char *fastmap = bufp->fastmap; |
register char *fastmap = bufp->fastmap; |
4548 |
unsigned char *pattern = bufp->buffer; |
|
4549 |
unsigned long size = bufp->used; |
#ifdef WCHAR |
4550 |
unsigned char *p = pattern; |
/* We need to cast pattern to (wchar_t*), because we casted this compiled |
4551 |
register unsigned char *pend = pattern + size; |
pattern to (char*) in regex_compile. */ |
4552 |
|
UCHAR_T *pattern = (UCHAR_T*)bufp->buffer; |
4553 |
|
register UCHAR_T *pend = (UCHAR_T*) (bufp->buffer + bufp->used); |
4554 |
|
#else /* BYTE */ |
4555 |
|
UCHAR_T *pattern = bufp->buffer; |
4556 |
|
register UCHAR_T *pend = pattern + bufp->used; |
4557 |
|
#endif /* WCHAR */ |
4558 |
|
UCHAR_T *p = pattern; |
4559 |
|
|
4560 |
|
#ifdef REL_ALLOC |
4561 |
|
/* This holds the pointer to the failure stack, when |
4562 |
|
it is allocated relocatably. */ |
4563 |
|
fail_stack_elt_t *failure_stack_ptr; |
4564 |
|
#endif |
4565 |
|
|
4566 |
/* Assume that each path through the pattern can be null until |
/* Assume that each path through the pattern can be null until |
4567 |
proven otherwise. We set this false at the bottom of switch |
proven otherwise. We set this false at the bottom of switch |
4573 |
boolean succeed_n_p = false; |
boolean succeed_n_p = false; |
4574 |
|
|
4575 |
assert (fastmap != NULL && p != NULL); |
assert (fastmap != NULL && p != NULL); |
4576 |
|
|
4577 |
INIT_FAIL_STACK (); |
INIT_FAIL_STACK (); |
4578 |
bzero (fastmap, 1 << BYTEWIDTH); /* Assume nothing's valid. */ |
bzero (fastmap, 1 << BYTEWIDTH); /* Assume nothing's valid. */ |
4579 |
bufp->fastmap_accurate = 1; /* It will be when we're done. */ |
bufp->fastmap_accurate = 1; /* It will be when we're done. */ |
4580 |
bufp->can_be_null = 0; |
bufp->can_be_null = 0; |
4581 |
|
|
4582 |
while (p != pend || !FAIL_STACK_EMPTY ()) |
while (1) |
4583 |
{ |
{ |
4584 |
if (p == pend) |
if (p == pend || *p == succeed) |
4585 |
{ |
{ |
4586 |
bufp->can_be_null |= path_can_be_null; |
/* We have reached the (effective) end of pattern. */ |
4587 |
|
if (!FAIL_STACK_EMPTY ()) |
4588 |
/* Reset for next path. */ |
{ |
4589 |
path_can_be_null = true; |
bufp->can_be_null |= path_can_be_null; |
4590 |
|
|
4591 |
p = fail_stack.stack[--fail_stack.avail]; |
/* Reset for next path. */ |
4592 |
|
path_can_be_null = true; |
4593 |
|
|
4594 |
|
p = fail_stack.stack[--fail_stack.avail].pointer; |
4595 |
|
|
4596 |
|
continue; |
4597 |
|
} |
4598 |
|
else |
4599 |
|
break; |
4600 |
} |
} |
4601 |
|
|
4602 |
/* We should never be about to go beyond the end of the pattern. */ |
/* We should never be about to go beyond the end of the pattern. */ |
4603 |
assert (p < pend); |
assert (p < pend); |
4604 |
|
|
4605 |
#ifdef SWITCH_ENUM_BUG |
switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++)) |
|
switch ((int) ((re_opcode_t) *p++)) |
|
|
#else |
|
|
switch ((re_opcode_t) *p++) |
|
|
#endif |
|
4606 |
{ |
{ |
4607 |
|
|
4608 |
/* I guess the idea here is to simply not bother with a fastmap |
/* I guess the idea here is to simply not bother with a fastmap |
4612 |
that is all we do. */ |
that is all we do. */ |
4613 |
case duplicate: |
case duplicate: |
4614 |
bufp->can_be_null = 1; |
bufp->can_be_null = 1; |
4615 |
return 0; |
goto done; |
4616 |
|
|
4617 |
|
|
4618 |
/* Following are the cases which match a character. These end |
/* Following are the cases which match a character. These end |
4619 |
with `break'. */ |
with `break'. */ |
4620 |
|
|
4621 |
|
#ifdef WCHAR |
4622 |
|
case exactn: |
4623 |
|
fastmap[truncate_wchar(p[1])] = 1; |
4624 |
|
break; |
4625 |
|
#else /* BYTE */ |
4626 |
case exactn: |
case exactn: |
4627 |
fastmap[p[1]] = 1; |
fastmap[p[1]] = 1; |
4628 |
break; |
break; |
4629 |
|
#endif /* WCHAR */ |
4630 |
|
#ifdef MBS_SUPPORT |
4631 |
|
case exactn_bin: |
4632 |
|
fastmap[p[1]] = 1; |
4633 |
|
break; |
4634 |
|
#endif |
4635 |
|
|
4636 |
|
#ifdef WCHAR |
4637 |
|
/* It is hard to distinguish fastmap from (multi byte) characters |
4638 |
|
which depends on current locale. */ |
4639 |
|
case charset: |
4640 |
|
case charset_not: |
4641 |
|
case wordchar: |
4642 |
|
case notwordchar: |
4643 |
|
bufp->can_be_null = 1; |
4644 |
|
goto done; |
4645 |
|
#else /* BYTE */ |
4646 |
case charset: |
case charset: |
4647 |
for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--) |
for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--) |
4648 |
if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))) |
if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))) |
4673 |
if (SYNTAX (j) != Sword) |
if (SYNTAX (j) != Sword) |
4674 |
fastmap[j] = 1; |
fastmap[j] = 1; |
4675 |
break; |
break; |
4676 |
|
#endif /* WCHAR */ |
4677 |
|
|
4678 |
case anychar: |
case anychar: |
4679 |
{ |
{ |
4690 |
/* Return if we have already set `can_be_null'; if we have, |
/* Return if we have already set `can_be_null'; if we have, |
4691 |
then the fastmap is irrelevant. Something's wrong here. */ |
then the fastmap is irrelevant. Something's wrong here. */ |
4692 |
else if (bufp->can_be_null) |
else if (bufp->can_be_null) |
4693 |
return 0; |
goto done; |
4694 |
|
|
4695 |
/* Otherwise, have to check alternative paths. */ |
/* Otherwise, have to check alternative paths. */ |
4696 |
break; |
break; |
4721 |
case at_dot: |
case at_dot: |
4722 |
case after_dot: |
case after_dot: |
4723 |
continue; |
continue; |
4724 |
#endif /* not emacs */ |
#endif /* emacs */ |
4725 |
|
|
4726 |
|
|
4727 |
case no_op: |
case no_op: |
4744 |
case jump_past_alt: |
case jump_past_alt: |
4745 |
case dummy_failure_jump: |
case dummy_failure_jump: |
4746 |
EXTRACT_NUMBER_AND_INCR (j, p); |
EXTRACT_NUMBER_AND_INCR (j, p); |
4747 |
p += j; |
p += j; |
4748 |
if (j > 0) |
if (j > 0) |
4749 |
continue; |
continue; |
4750 |
|
|
4751 |
/* Jump backward implies we just went through the body of a |
/* Jump backward implies we just went through the body of a |
4752 |
loop and matched nothing. Opcode jumped to should be |
loop and matched nothing. Opcode jumped to should be |
4753 |
`on_failure_jump' or `succeed_n'. Just treat it like an |
`on_failure_jump' or `succeed_n'. Just treat it like an |
4759 |
|
|
4760 |
p++; |
p++; |
4761 |
EXTRACT_NUMBER_AND_INCR (j, p); |
EXTRACT_NUMBER_AND_INCR (j, p); |
4762 |
p += j; |
p += j; |
4763 |
|
|
4764 |
/* If what's on the stack is where we are now, pop it. */ |
/* If what's on the stack is where we are now, pop it. */ |
4765 |
if (!FAIL_STACK_EMPTY () |
if (!FAIL_STACK_EMPTY () |
4766 |
&& fail_stack.stack[fail_stack.avail - 1] == p) |
&& fail_stack.stack[fail_stack.avail - 1].pointer == p) |
4767 |
fail_stack.avail--; |
fail_stack.avail--; |
4768 |
|
|
4769 |
continue; |
continue; |
4784 |
if (p + j < pend) |
if (p + j < pend) |
4785 |
{ |
{ |
4786 |
if (!PUSH_PATTERN_OP (p + j, fail_stack)) |
if (!PUSH_PATTERN_OP (p + j, fail_stack)) |
4787 |
return -2; |
{ |
4788 |
|
RESET_FAIL_STACK (); |
4789 |
|
return -2; |
4790 |
|
} |
4791 |
} |
} |
4792 |
else |
else |
4793 |
bufp->can_be_null = 1; |
bufp->can_be_null = 1; |
4803 |
|
|
4804 |
case succeed_n: |
case succeed_n: |
4805 |
/* Get to the number of times to succeed. */ |
/* Get to the number of times to succeed. */ |
4806 |
p += 2; |
p += OFFSET_ADDRESS_SIZE; |
4807 |
|
|
4808 |
/* Increment p past the n for when k != 0. */ |
/* Increment p past the n for when k != 0. */ |
4809 |
EXTRACT_NUMBER_AND_INCR (k, p); |
EXTRACT_NUMBER_AND_INCR (k, p); |
4810 |
if (k == 0) |
if (k == 0) |
4811 |
{ |
{ |
4812 |
p -= 4; |
p -= 2 * OFFSET_ADDRESS_SIZE; |
4813 |
succeed_n_p = true; /* Spaghetti code alert. */ |
succeed_n_p = true; /* Spaghetti code alert. */ |
4814 |
goto handle_on_failure_jump; |
goto handle_on_failure_jump; |
4815 |
} |
} |
4817 |
|
|
4818 |
|
|
4819 |
case set_number_at: |
case set_number_at: |
4820 |
p += 4; |
p += 2 * OFFSET_ADDRESS_SIZE; |
4821 |
continue; |
continue; |
4822 |
|
|
4823 |
|
|
4844 |
/* Set `can_be_null' for the last path (also the first path, if the |
/* Set `can_be_null' for the last path (also the first path, if the |
4845 |
pattern is empty). */ |
pattern is empty). */ |
4846 |
bufp->can_be_null |= path_can_be_null; |
bufp->can_be_null |= path_can_be_null; |
4847 |
|
|
4848 |
|
done: |
4849 |
|
RESET_FAIL_STACK (); |
4850 |
return 0; |
return 0; |
4851 |
|
} |
4852 |
|
|
4853 |
|
#else /* not INSIDE_RECURSION */ |
4854 |
|
|
4855 |
|
int |
4856 |
|
re_compile_fastmap (struct re_pattern_buffer *bufp) |
4857 |
|
{ |
4858 |
|
# ifdef MBS_SUPPORT |
4859 |
|
if (MB_CUR_MAX != 1) |
4860 |
|
return wcs_re_compile_fastmap(bufp); |
4861 |
|
else |
4862 |
|
# endif |
4863 |
|
return byte_re_compile_fastmap(bufp); |
4864 |
} /* re_compile_fastmap */ |
} /* re_compile_fastmap */ |
4865 |
|
#ifdef _LIBC |
4866 |
|
weak_alias (__re_compile_fastmap, re_compile_fastmap) |
4867 |
|
#endif |
4868 |
|
|
4869 |
|
|
4870 |
/* Set REGS to hold NUM_REGS registers, storing them in STARTS and |
/* Set REGS to hold NUM_REGS registers, storing them in STARTS and |
4871 |
ENDS. Subsequent matches using PATTERN_BUFFER and REGS will use |
ENDS. Subsequent matches using PATTERN_BUFFER and REGS will use |
4872 |
this memory for recording register information. STARTS and ENDS |
this memory for recording register information. STARTS and ENDS |
4881 |
freeing the old data. */ |
freeing the old data. */ |
4882 |
|
|
4883 |
void |
void |
4884 |
re_set_registers (bufp, regs, num_regs, starts, ends) |
re_set_registers (struct re_pattern_buffer *bufp, |
4885 |
struct re_pattern_buffer *bufp; |
struct re_registers *regs, |
4886 |
struct re_registers *regs; |
unsigned int num_regs, |
4887 |
unsigned num_regs; |
regoff_t *starts, regoff_t *ends) |
|
regoff_t *starts, *ends; |
|
4888 |
{ |
{ |
4889 |
if (num_regs) |
if (num_regs) |
4890 |
{ |
{ |
4900 |
regs->start = regs->end = (regoff_t *) 0; |
regs->start = regs->end = (regoff_t *) 0; |
4901 |
} |
} |
4902 |
} |
} |
4903 |
|
#ifdef _LIBC |
4904 |
|
weak_alias (__re_set_registers, re_set_registers) |
4905 |
|
#endif |
4906 |
|
|
4907 |
/* Searching routines. */ |
/* Searching routines. */ |
4908 |
|
|
4909 |
/* Like re_search_2, below, but only one string is specified, and |
/* Like re_search_2, below, but only one string is specified, and |
4910 |
doesn't let you say where to stop matching. */ |
doesn't let you say where to stop matching. */ |
4911 |
|
|
4912 |
int |
int |
4913 |
re_search (bufp, string, size, startpos, range, regs) |
re_search (struct re_pattern_buffer *bufp, |
4914 |
struct re_pattern_buffer *bufp; |
const char *string, |
4915 |
const char *string; |
int size, int startpos, int range, |
4916 |
int size, startpos, range; |
struct re_registers *regs) |
|
struct re_registers *regs; |
|
4917 |
{ |
{ |
4918 |
return re_search_2 (bufp, NULL, 0, string, size, startpos, range, |
return re_search_2 (bufp, NULL, 0, string, size, startpos, range, |
4919 |
regs, size); |
regs, size); |
4920 |
} |
} |
4921 |
|
#ifdef _LIBC |
4922 |
|
weak_alias (__re_search, re_search) |
4923 |
|
#endif |
4924 |
|
|
4925 |
|
|
4926 |
/* Using the compiled pattern in BUFP->buffer, first tries to match the |
/* Using the compiled pattern in BUFP->buffer, first tries to match the |
4927 |
virtual concatenation of STRING1 and STRING2, starting first at index |
virtual concatenation of STRING1 and STRING2, starting first at index |
4928 |
STARTPOS, then at STARTPOS + 1, and so on. |
STARTPOS, then at STARTPOS + 1, and so on. |
4929 |
|
|
4930 |
STRING1 and STRING2 have length SIZE1 and SIZE2, respectively. |
STRING1 and STRING2 have length SIZE1 and SIZE2, respectively. |
4931 |
|
|
4932 |
RANGE is how far to scan while trying to match. RANGE = 0 means try |
RANGE is how far to scan while trying to match. RANGE = 0 means try |
4933 |
only at STARTPOS; in general, the last start tried is STARTPOS + |
only at STARTPOS; in general, the last start tried is STARTPOS + |
4934 |
RANGE. |
RANGE. |
4935 |
|
|
4936 |
In REGS, return the indices of the virtual concatenation of STRING1 |
In REGS, return the indices of the virtual concatenation of STRING1 |
4937 |
and STRING2 that matched the entire BUFP->buffer and its contained |
and STRING2 that matched the entire BUFP->buffer and its contained |
4938 |
subexpressions. |
subexpressions. |
4939 |
|
|
4940 |
Do not consider matching one past the index STOP in the virtual |
Do not consider matching one past the index STOP in the virtual |
4941 |
concatenation of STRING1 and STRING2. |
concatenation of STRING1 and STRING2. |
4942 |
|
|
4945 |
stack overflow). */ |
stack overflow). */ |
4946 |
|
|
4947 |
int |
int |
4948 |
re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop) |
re_search_2 (struct re_pattern_buffer *bufp, |
4949 |
struct re_pattern_buffer *bufp; |
const char *string1, int size1, |
4950 |
const char *string1, *string2; |
const char *string2, int size2, |
4951 |
int size1, size2; |
int startpos, int range, |
4952 |
int startpos; |
struct re_registers *regs, |
4953 |
int range; |
int stop) |
4954 |
struct re_registers *regs; |
{ |
4955 |
int stop; |
# ifdef MBS_SUPPORT |
4956 |
|
if (MB_CUR_MAX != 1) |
4957 |
|
return wcs_re_search_2 (bufp, string1, size1, string2, size2, startpos, |
4958 |
|
range, regs, stop); |
4959 |
|
else |
4960 |
|
# endif |
4961 |
|
return byte_re_search_2 (bufp, string1, size1, string2, size2, startpos, |
4962 |
|
range, regs, stop); |
4963 |
|
} /* re_search_2 */ |
4964 |
|
#ifdef _LIBC |
4965 |
|
weak_alias (__re_search_2, re_search_2) |
4966 |
|
#endif |
4967 |
|
|
4968 |
|
#endif /* not INSIDE_RECURSION */ |
4969 |
|
|
4970 |
|
#ifdef INSIDE_RECURSION |
4971 |
|
|
4972 |
|
#ifdef MATCH_MAY_ALLOCATE |
4973 |
|
# define FREE_VAR(var) if (var) REGEX_FREE (var); var = NULL |
4974 |
|
#else |
4975 |
|
# define FREE_VAR(var) if (var) free (var); var = NULL |
4976 |
|
#endif |
4977 |
|
|
4978 |
|
#ifdef WCHAR |
4979 |
|
# define MAX_ALLOCA_SIZE 2000 |
4980 |
|
|
4981 |
|
# define FREE_WCS_BUFFERS() \ |
4982 |
|
do { \ |
4983 |
|
if (size1 > MAX_ALLOCA_SIZE) \ |
4984 |
|
{ \ |
4985 |
|
free (wcs_string1); \ |
4986 |
|
free (mbs_offset1); \ |
4987 |
|
} \ |
4988 |
|
else \ |
4989 |
|
{ \ |
4990 |
|
FREE_VAR (wcs_string1); \ |
4991 |
|
FREE_VAR (mbs_offset1); \ |
4992 |
|
} \ |
4993 |
|
if (size2 > MAX_ALLOCA_SIZE) \ |
4994 |
|
{ \ |
4995 |
|
free (wcs_string2); \ |
4996 |
|
free (mbs_offset2); \ |
4997 |
|
} \ |
4998 |
|
else \ |
4999 |
|
{ \ |
5000 |
|
FREE_VAR (wcs_string2); \ |
5001 |
|
FREE_VAR (mbs_offset2); \ |
5002 |
|
} \ |
5003 |
|
} while (0) |
5004 |
|
|
5005 |
|
#endif |
5006 |
|
|
5007 |
|
|
5008 |
|
static int |
5009 |
|
PREFIX(re_search_2) (struct re_pattern_buffer *bufp, |
5010 |
|
const char *string1, int size1, |
5011 |
|
const char *string2, int size2, |
5012 |
|
int startpos, int range, |
5013 |
|
struct re_registers *regs, |
5014 |
|
int stop) |
5015 |
{ |
{ |
5016 |
int val; |
int val; |
5017 |
register char *fastmap = bufp->fastmap; |
register char *fastmap = bufp->fastmap; |
5018 |
register char *translate = bufp->translate; |
register RE_TRANSLATE_TYPE translate = bufp->translate; |
5019 |
int total_size = size1 + size2; |
int total_size = size1 + size2; |
5020 |
int endpos = startpos + range; |
int endpos = startpos + range; |
5021 |
|
#ifdef WCHAR |
5022 |
|
/* We need wchar_t* buffers correspond to cstring1, cstring2. */ |
5023 |
|
wchar_t *wcs_string1 = NULL, *wcs_string2 = NULL; |
5024 |
|
/* We need the size of wchar_t buffers correspond to csize1, csize2. */ |
5025 |
|
int wcs_size1 = 0, wcs_size2 = 0; |
5026 |
|
/* offset buffer for optimizatoin. See convert_mbs_to_wc. */ |
5027 |
|
int *mbs_offset1 = NULL, *mbs_offset2 = NULL; |
5028 |
|
/* They hold whether each wchar_t is binary data or not. */ |
5029 |
|
char *is_binary = NULL; |
5030 |
|
#endif /* WCHAR */ |
5031 |
|
|
5032 |
/* Check for out-of-range STARTPOS. */ |
/* Check for out-of-range STARTPOS. */ |
5033 |
if (startpos < 0 || startpos > total_size) |
if (startpos < 0 || startpos > total_size) |
5034 |
return -1; |
return -1; |
5035 |
|
|
5036 |
/* Fix up RANGE if it might eventually take us outside |
/* Fix up RANGE if it might eventually take us outside |
5037 |
the virtual concatenation of STRING1 and STRING2. */ |
the virtual concatenation of STRING1 and STRING2. |
5038 |
if (endpos < -1) |
Make sure we won't move STARTPOS below 0 or above TOTAL_SIZE. */ |
5039 |
range = -1 - startpos; |
if (endpos < 0) |
5040 |
|
range = 0 - startpos; |
5041 |
else if (endpos > total_size) |
else if (endpos > total_size) |
5042 |
range = total_size - startpos; |
range = total_size - startpos; |
5043 |
|
|
5044 |
/* If the search isn't to be a backwards one, don't waste time in a |
/* If the search isn't to be a backwards one, don't waste time in a |
5045 |
search for a pattern that must be anchored. */ |
search for a pattern that must be anchored. */ |
5046 |
if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == begbuf && range > 0) |
if (bufp->used > 0 && range > 0 |
5047 |
|
&& ((re_opcode_t) bufp->buffer[0] == begbuf |
5048 |
|
/* `begline' is like `begbuf' if it cannot match at newlines. */ |
5049 |
|
|| ((re_opcode_t) bufp->buffer[0] == begline |
5050 |
|
&& !bufp->newline_anchor))) |
5051 |
{ |
{ |
5052 |
if (startpos > 0) |
if (startpos > 0) |
5053 |
return -1; |
return -1; |
5055 |
range = 1; |
range = 1; |
5056 |
} |
} |
5057 |
|
|
5058 |
|
#ifdef emacs |
5059 |
|
/* In a forward search for something that starts with \=. |
5060 |
|
don't keep searching past point. */ |
5061 |
|
if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == at_dot && range > 0) |
5062 |
|
{ |
5063 |
|
range = PT - startpos; |
5064 |
|
if (range <= 0) |
5065 |
|
return -1; |
5066 |
|
} |
5067 |
|
#endif /* emacs */ |
5068 |
|
|
5069 |
/* Update the fastmap now if not correct already. */ |
/* Update the fastmap now if not correct already. */ |
5070 |
if (fastmap && !bufp->fastmap_accurate) |
if (fastmap && !bufp->fastmap_accurate) |
5071 |
if (re_compile_fastmap (bufp) == -2) |
if (re_compile_fastmap (bufp) == -2) |
5072 |
return -2; |
return -2; |
5073 |
|
|
5074 |
|
#ifdef WCHAR |
5075 |
|
/* Allocate wchar_t array for wcs_string1 and wcs_string2 and |
5076 |
|
fill them with converted string. */ |
5077 |
|
if (size1 != 0) |
5078 |
|
{ |
5079 |
|
if (size1 > MAX_ALLOCA_SIZE) |
5080 |
|
{ |
5081 |
|
wcs_string1 = TALLOC (size1 + 1, CHAR_T); |
5082 |
|
mbs_offset1 = TALLOC (size1 + 1, int); |
5083 |
|
is_binary = TALLOC (size1 + 1, char); |
5084 |
|
} |
5085 |
|
else |
5086 |
|
{ |
5087 |
|
wcs_string1 = REGEX_TALLOC (size1 + 1, CHAR_T); |
5088 |
|
mbs_offset1 = REGEX_TALLOC (size1 + 1, int); |
5089 |
|
is_binary = REGEX_TALLOC (size1 + 1, char); |
5090 |
|
} |
5091 |
|
if (!wcs_string1 || !mbs_offset1 || !is_binary) |
5092 |
|
{ |
5093 |
|
if (size1 > MAX_ALLOCA_SIZE) |
5094 |
|
{ |
5095 |
|
free (wcs_string1); |
5096 |
|
free (mbs_offset1); |
5097 |
|
free (is_binary); |
5098 |
|
} |
5099 |
|
else |
5100 |
|
{ |
5101 |
|
FREE_VAR (wcs_string1); |
5102 |
|
FREE_VAR (mbs_offset1); |
5103 |
|
FREE_VAR (is_binary); |
5104 |
|
} |
5105 |
|
return -2; |
5106 |
|
} |
5107 |
|
wcs_size1 = convert_mbs_to_wcs(wcs_string1, string1, size1, |
5108 |
|
mbs_offset1, is_binary); |
5109 |
|
wcs_string1[wcs_size1] = L'\0'; /* for a sentinel */ |
5110 |
|
if (size1 > MAX_ALLOCA_SIZE) |
5111 |
|
free (is_binary); |
5112 |
|
else |
5113 |
|
FREE_VAR (is_binary); |
5114 |
|
} |
5115 |
|
if (size2 != 0) |
5116 |
|
{ |
5117 |
|
if (size2 > MAX_ALLOCA_SIZE) |
5118 |
|
{ |
5119 |
|
wcs_string2 = TALLOC (size2 + 1, CHAR_T); |
5120 |
|
mbs_offset2 = TALLOC (size2 + 1, int); |
5121 |
|
is_binary = TALLOC (size2 + 1, char); |
5122 |
|
} |
5123 |
|
else |
5124 |
|
{ |
5125 |
|
wcs_string2 = REGEX_TALLOC (size2 + 1, CHAR_T); |
5126 |
|
mbs_offset2 = REGEX_TALLOC (size2 + 1, int); |
5127 |
|
is_binary = REGEX_TALLOC (size2 + 1, char); |
5128 |
|
} |
5129 |
|
if (!wcs_string2 || !mbs_offset2 || !is_binary) |
5130 |
|
{ |
5131 |
|
FREE_WCS_BUFFERS (); |
5132 |
|
if (size2 > MAX_ALLOCA_SIZE) |
5133 |
|
free (is_binary); |
5134 |
|
else |
5135 |
|
FREE_VAR (is_binary); |
5136 |
|
return -2; |
5137 |
|
} |
5138 |
|
wcs_size2 = convert_mbs_to_wcs(wcs_string2, string2, size2, |
5139 |
|
mbs_offset2, is_binary); |
5140 |
|
wcs_string2[wcs_size2] = L'\0'; /* for a sentinel */ |
5141 |
|
if (size2 > MAX_ALLOCA_SIZE) |
5142 |
|
free (is_binary); |
5143 |
|
else |
5144 |
|
FREE_VAR (is_binary); |
5145 |
|
} |
5146 |
|
#endif /* WCHAR */ |
5147 |
|
|
5148 |
|
|
5149 |
/* Loop through the string, looking for a place to start matching. */ |
/* Loop through the string, looking for a place to start matching. */ |
5150 |
for (;;) |
for (;;) |
5151 |
{ |
{ |
5152 |
/* If a fastmap is supplied, skip quickly over characters that |
/* If a fastmap is supplied, skip quickly over characters that |
5153 |
cannot be the start of a match. If the pattern can match the |
cannot be the start of a match. If the pattern can match the |
5154 |
null string, however, we don't need to skip characters; we want |
null string, however, we don't need to skip characters; we want |
5165 |
lim = range - (size1 - startpos); |
lim = range - (size1 - startpos); |
5166 |
|
|
5167 |
d = (startpos >= size1 ? string2 - size1 : string1) + startpos; |
d = (startpos >= size1 ? string2 - size1 : string1) + startpos; |
5168 |
|
|
5169 |
/* Written out as an if-else to avoid testing `translate' |
/* Written out as an if-else to avoid testing `translate' |
5170 |
inside the loop. */ |
inside the loop. */ |
5171 |
if (translate) |
if (translate) |
5181 |
} |
} |
5182 |
else /* Searching backwards. */ |
else /* Searching backwards. */ |
5183 |
{ |
{ |
5184 |
register char c = (size1 == 0 || startpos >= size1 |
register CHAR_T c = (size1 == 0 || startpos >= size1 |
5185 |
? string2[startpos - size1] |
? string2[startpos - size1] |
5186 |
: string1[startpos]); |
: string1[startpos]); |
5187 |
|
|
5188 |
if (!fastmap[(unsigned char) TRANSLATE (c)]) |
if (!fastmap[(unsigned char) TRANSLATE (c)]) |
5189 |
goto advance; |
goto advance; |
5193 |
/* If can't match the null string, and that's all we have left, fail. */ |
/* If can't match the null string, and that's all we have left, fail. */ |
5194 |
if (range >= 0 && startpos == total_size && fastmap |
if (range >= 0 && startpos == total_size && fastmap |
5195 |
&& !bufp->can_be_null) |
&& !bufp->can_be_null) |
5196 |
return -1; |
{ |
5197 |
|
#ifdef WCHAR |
5198 |
|
FREE_WCS_BUFFERS (); |
5199 |
|
#endif |
5200 |
|
return -1; |
5201 |
|
} |
5202 |
|
|
5203 |
|
#ifdef WCHAR |
5204 |
|
val = wcs_re_match_2_internal (bufp, string1, size1, string2, |
5205 |
|
size2, startpos, regs, stop, |
5206 |
|
wcs_string1, wcs_size1, |
5207 |
|
wcs_string2, wcs_size2, |
5208 |
|
mbs_offset1, mbs_offset2); |
5209 |
|
#else /* BYTE */ |
5210 |
|
val = byte_re_match_2_internal (bufp, string1, size1, string2, |
5211 |
|
size2, startpos, regs, stop); |
5212 |
|
#endif /* BYTE */ |
5213 |
|
|
|
val = re_match_2_internal (bufp, string1, size1, string2, size2, |
|
|
startpos, regs, stop); |
|
5214 |
#ifndef REGEX_MALLOC |
#ifndef REGEX_MALLOC |
5215 |
#ifdef C_ALLOCA |
# ifdef C_ALLOCA |
5216 |
alloca (0); |
alloca (0); |
5217 |
#endif |
# endif |
5218 |
#endif |
#endif |
5219 |
|
|
5220 |
if (val >= 0) |
if (val >= 0) |
5221 |
return startpos; |
{ |
5222 |
|
#ifdef WCHAR |
5223 |
|
FREE_WCS_BUFFERS (); |
5224 |
|
#endif |
5225 |
|
return startpos; |
5226 |
|
} |
5227 |
|
|
5228 |
if (val == -2) |
if (val == -2) |
5229 |
return -2; |
{ |
5230 |
|
#ifdef WCHAR |
5231 |
|
FREE_WCS_BUFFERS (); |
5232 |
|
#endif |
5233 |
|
return -2; |
5234 |
|
} |
5235 |
|
|
5236 |
advance: |
advance: |
5237 |
if (!range) |
if (!range) |
5238 |
break; |
break; |
5239 |
else if (range > 0) |
else if (range > 0) |
5240 |
{ |
{ |
5241 |
range--; |
range--; |
5242 |
startpos++; |
startpos++; |
5243 |
} |
} |
5244 |
else |
else |
5245 |
{ |
{ |
5246 |
range++; |
range++; |
5247 |
startpos--; |
startpos--; |
5248 |
} |
} |
5249 |
} |
} |
5250 |
|
#ifdef WCHAR |
5251 |
|
FREE_WCS_BUFFERS (); |
5252 |
|
#endif |
5253 |
return -1; |
return -1; |
5254 |
} /* re_search_2 */ |
} |
|
|
|
|
/* Declarations and macros for re_match_2. */ |
|
|
|
|
|
static int bcmp_translate (); |
|
|
static boolean alt_match_null_string_p (), |
|
|
common_op_match_null_string_p (), |
|
|
group_match_null_string_p (); |
|
5255 |
|
|
5256 |
|
#ifdef WCHAR |
5257 |
|
/* This converts PTR, a pointer into one of the search wchar_t strings |
5258 |
|
`string1' and `string2' into an multibyte string offset from the |
5259 |
|
beginning of that string. We use mbs_offset to optimize. |
5260 |
|
See convert_mbs_to_wcs. */ |
5261 |
|
# define POINTER_TO_OFFSET(ptr) \ |
5262 |
|
(FIRST_STRING_P (ptr) \ |
5263 |
|
? ((regoff_t)(mbs_offset1 != NULL? mbs_offset1[(ptr)-string1] : 0)) \ |
5264 |
|
: ((regoff_t)((mbs_offset2 != NULL? mbs_offset2[(ptr)-string2] : 0) \ |
5265 |
|
+ csize1))) |
5266 |
|
#else /* BYTE */ |
5267 |
/* This converts PTR, a pointer into one of the search strings `string1' |
/* This converts PTR, a pointer into one of the search strings `string1' |
5268 |
and `string2' into an offset from the beginning of that string. */ |
and `string2' into an offset from the beginning of that string. */ |
5269 |
#define POINTER_TO_OFFSET(ptr) \ |
# define POINTER_TO_OFFSET(ptr) \ |
5270 |
(FIRST_STRING_P (ptr) \ |
(FIRST_STRING_P (ptr) \ |
5271 |
? ((regoff_t) ((ptr) - string1)) \ |
? ((regoff_t) ((ptr) - string1)) \ |
5272 |
: ((regoff_t) ((ptr) - string2 + size1))) |
: ((regoff_t) ((ptr) - string2 + size1))) |
5273 |
|
#endif /* WCHAR */ |
5274 |
|
|
5275 |
/* Macros for dealing with the split strings in re_match_2. */ |
/* Macros for dealing with the split strings in re_match_2. */ |
5276 |
|
|
5289 |
dend = end_match_2; \ |
dend = end_match_2; \ |
5290 |
} |
} |
5291 |
|
|
|
|
|
5292 |
/* Test if at very beginning or at very end of the virtual concatenation |
/* Test if at very beginning or at very end of the virtual concatenation |
5293 |
of `string1' and `string2'. If only one string, it's `string2'. */ |
of `string1' and `string2'. If only one string, it's `string2'. */ |
5294 |
#define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2) |
#define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2) |
5295 |
#define AT_STRINGS_END(d) ((d) == end2) |
#define AT_STRINGS_END(d) ((d) == end2) |
5296 |
|
|
5297 |
|
|
5298 |
/* Test if D points to a character which is word-constituent. We have |
/* Test if D points to a character which is word-constituent. We have |
5299 |
two special cases to check for: if past the end of string1, look at |
two special cases to check for: if past the end of string1, look at |
5300 |
the first character in string2; and if before the beginning of |
the first character in string2; and if before the beginning of |
5301 |
string2, look at the last character in string1. */ |
string2, look at the last character in string1. */ |
5302 |
#define WORDCHAR_P(d) \ |
#ifdef WCHAR |
5303 |
|
/* Use internationalized API instead of SYNTAX. */ |
5304 |
|
# define WORDCHAR_P(d) \ |
5305 |
|
(iswalnum ((wint_t)((d) == end1 ? *string2 \ |
5306 |
|
: (d) == string2 - 1 ? *(end1 - 1) : *(d))) != 0 \ |
5307 |
|
|| ((d) == end1 ? *string2 \ |
5308 |
|
: (d) == string2 - 1 ? *(end1 - 1) : *(d)) == L'_') |
5309 |
|
#else /* BYTE */ |
5310 |
|
# define WORDCHAR_P(d) \ |
5311 |
(SYNTAX ((d) == end1 ? *string2 \ |
(SYNTAX ((d) == end1 ? *string2 \ |
5312 |
: (d) == string2 - 1 ? *(end1 - 1) : *(d)) \ |
: (d) == string2 - 1 ? *(end1 - 1) : *(d)) \ |
5313 |
== Sword) |
== Sword) |
5314 |
|
#endif /* WCHAR */ |
5315 |
|
|
5316 |
|
/* Disabled due to a compiler bug -- see comment at case wordbound */ |
5317 |
|
#if 0 |
5318 |
/* Test if the character before D and the one at D differ with respect |
/* Test if the character before D and the one at D differ with respect |
5319 |
to being word-constituent. */ |
to being word-constituent. */ |
5320 |
#define AT_WORD_BOUNDARY(d) \ |
#define AT_WORD_BOUNDARY(d) \ |
5321 |
(AT_STRINGS_BEG (d) || AT_STRINGS_END (d) \ |
(AT_STRINGS_BEG (d) || AT_STRINGS_END (d) \ |
5322 |
|| WORDCHAR_P (d - 1) != WORDCHAR_P (d)) |
|| WORDCHAR_P (d - 1) != WORDCHAR_P (d)) |
5323 |
|
#endif |
5324 |
|
|
5325 |
/* Free everything we malloc. */ |
/* Free everything we malloc. */ |
5326 |
#ifdef MATCH_MAY_ALLOCATE |
#ifdef MATCH_MAY_ALLOCATE |
5327 |
#ifdef REGEX_MALLOC |
# ifdef WCHAR |
5328 |
#define FREE_VAR(var) if (var) free (var); var = NULL |
# define FREE_VARIABLES() \ |
|
#define FREE_VARIABLES() \ |
|
5329 |
do { \ |
do { \ |
5330 |
FREE_VAR (fail_stack.stack); \ |
REGEX_FREE_STACK (fail_stack.stack); \ |
5331 |
FREE_VAR (regstart); \ |
FREE_VAR (regstart); \ |
5332 |
FREE_VAR (regend); \ |
FREE_VAR (regend); \ |
5333 |
FREE_VAR (old_regstart); \ |
FREE_VAR (old_regstart); \ |
5337 |
FREE_VAR (reg_info); \ |
FREE_VAR (reg_info); \ |
5338 |
FREE_VAR (reg_dummy); \ |
FREE_VAR (reg_dummy); \ |
5339 |
FREE_VAR (reg_info_dummy); \ |
FREE_VAR (reg_info_dummy); \ |
5340 |
|
if (!cant_free_wcs_buf) \ |
5341 |
|
{ \ |
5342 |
|
FREE_VAR (string1); \ |
5343 |
|
FREE_VAR (string2); \ |
5344 |
|
FREE_VAR (mbs_offset1); \ |
5345 |
|
FREE_VAR (mbs_offset2); \ |
5346 |
|
} \ |
5347 |
} while (0) |
} while (0) |
5348 |
#else /* not REGEX_MALLOC */ |
# else /* BYTE */ |
5349 |
/* This used to do alloca (0), but now we do that in the caller. */ |
# define FREE_VARIABLES() \ |
5350 |
#define FREE_VARIABLES() /* Nothing */ |
do { \ |
5351 |
#endif /* not REGEX_MALLOC */ |
REGEX_FREE_STACK (fail_stack.stack); \ |
5352 |
|
FREE_VAR (regstart); \ |
5353 |
|
FREE_VAR (regend); \ |
5354 |
|
FREE_VAR (old_regstart); \ |
5355 |
|
FREE_VAR (old_regend); \ |
5356 |
|
FREE_VAR (best_regstart); \ |
5357 |
|
FREE_VAR (best_regend); \ |
5358 |
|
FREE_VAR (reg_info); \ |
5359 |
|
FREE_VAR (reg_dummy); \ |
5360 |
|
FREE_VAR (reg_info_dummy); \ |
5361 |
|
} while (0) |
5362 |
|
# endif /* WCHAR */ |
5363 |
#else |
#else |
5364 |
#define FREE_VARIABLES() /* Do nothing! */ |
# ifdef WCHAR |
5365 |
|
# define FREE_VARIABLES() \ |
5366 |
|
do { \ |
5367 |
|
if (!cant_free_wcs_buf) \ |
5368 |
|
{ \ |
5369 |
|
FREE_VAR (string1); \ |
5370 |
|
FREE_VAR (string2); \ |
5371 |
|
FREE_VAR (mbs_offset1); \ |
5372 |
|
FREE_VAR (mbs_offset2); \ |
5373 |
|
} \ |
5374 |
|
} while (0) |
5375 |
|
# else /* BYTE */ |
5376 |
|
# define FREE_VARIABLES() ((void)0) /* Do nothing! But inhibit gcc warning. */ |
5377 |
|
# endif /* WCHAR */ |
5378 |
#endif /* not MATCH_MAY_ALLOCATE */ |
#endif /* not MATCH_MAY_ALLOCATE */ |
5379 |
|
|
5380 |
/* These values must meet several constraints. They must not be valid |
/* These values must meet several constraints. They must not be valid |
5387 |
#define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH) |
#define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH) |
5388 |
#define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1) |
#define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1) |
5389 |
|
|
5390 |
|
#else /* not INSIDE_RECURSION */ |
5391 |
/* Matching routines. */ |
/* Matching routines. */ |
5392 |
|
|
5393 |
#ifndef emacs /* Emacs never uses this. */ |
#ifndef emacs /* Emacs never uses this. */ |
5394 |
/* re_match is like re_match_2 except it takes only a single string. */ |
/* re_match is like re_match_2 except it takes only a single string. */ |
5395 |
|
|
5396 |
int |
int |
5397 |
re_match (bufp, string, size, pos, regs) |
re_match (struct re_pattern_buffer *bufp, |
5398 |
struct re_pattern_buffer *bufp; |
const char *string, |
5399 |
const char *string; |
int size, int pos, |
5400 |
int size, pos; |
struct re_registers *regs) |
|
struct re_registers *regs; |
|
5401 |
{ |
{ |
5402 |
int result = re_match_2_internal (bufp, NULL, 0, string, size, |
int result; |
5403 |
pos, regs, size); |
# ifdef MBS_SUPPORT |
5404 |
|
if (MB_CUR_MAX != 1) |
5405 |
|
result = wcs_re_match_2_internal (bufp, NULL, 0, string, size, |
5406 |
|
pos, regs, size, |
5407 |
|
NULL, 0, NULL, 0, NULL, NULL); |
5408 |
|
else |
5409 |
|
# endif |
5410 |
|
result = byte_re_match_2_internal (bufp, NULL, 0, string, size, |
5411 |
|
pos, regs, size); |
5412 |
|
# ifndef REGEX_MALLOC |
5413 |
|
# ifdef C_ALLOCA |
5414 |
alloca (0); |
alloca (0); |
5415 |
|
# endif |
5416 |
|
# endif |
5417 |
return result; |
return result; |
5418 |
} |
} |
5419 |
|
# ifdef _LIBC |
5420 |
|
weak_alias (__re_match, re_match) |
5421 |
|
# endif |
5422 |
#endif /* not emacs */ |
#endif /* not emacs */ |
5423 |
|
|
5424 |
|
#endif /* not INSIDE_RECURSION */ |
5425 |
|
|
5426 |
|
#ifdef INSIDE_RECURSION |
5427 |
|
static boolean PREFIX(group_match_null_string_p) (UCHAR_T **p, |
5428 |
|
UCHAR_T *end, |
5429 |
|
PREFIX(register_info_type) *reg_info); |
5430 |
|
static boolean PREFIX(alt_match_null_string_p) (UCHAR_T *p, |
5431 |
|
UCHAR_T *end, |
5432 |
|
PREFIX(register_info_type) *reg_info); |
5433 |
|
static boolean PREFIX(common_op_match_null_string_p) (UCHAR_T **p, |
5434 |
|
UCHAR_T *end, |
5435 |
|
PREFIX(register_info_type) *reg_info); |
5436 |
|
static int PREFIX(bcmp_translate) (const CHAR_T *s1, const CHAR_T *s2, |
5437 |
|
int len, char *translate); |
5438 |
|
#else /* not INSIDE_RECURSION */ |
5439 |
|
|
5440 |
/* re_match_2 matches the compiled pattern in BUFP against the |
/* re_match_2 matches the compiled pattern in BUFP against the |
5441 |
the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1 |
the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1 |
5442 |
and SIZE2, respectively). We start matching at POS, and stop |
and SIZE2, respectively). We start matching at POS, and stop |
5443 |
matching at STOP. |
matching at STOP. |
5444 |
|
|
5445 |
If REGS is non-null and the `no_sub' field of BUFP is nonzero, we |
If REGS is non-null and the `no_sub' field of BUFP is nonzero, we |
5446 |
store offsets for the substring each group matched in REGS. See the |
store offsets for the substring each group matched in REGS. See the |
5447 |
documentation for exactly how many groups we fill. |
documentation for exactly how many groups we fill. |
5451 |
matched substring. */ |
matched substring. */ |
5452 |
|
|
5453 |
int |
int |
5454 |
re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop) |
re_match_2 (struct re_pattern_buffer *bufp, |
5455 |
struct re_pattern_buffer *bufp; |
const char *string1, int size1, |
5456 |
const char *string1, *string2; |
const char *string2, int size2, |
5457 |
int size1, size2; |
int pos, struct re_registers *regs, |
5458 |
int pos; |
int stop) |
|
struct re_registers *regs; |
|
|
int stop; |
|
5459 |
{ |
{ |
5460 |
int result = re_match_2_internal (bufp, string1, size1, string2, size2, |
int result; |
5461 |
pos, regs, stop); |
# ifdef MBS_SUPPORT |
5462 |
|
if (MB_CUR_MAX != 1) |
5463 |
|
result = wcs_re_match_2_internal (bufp, string1, size1, string2, size2, |
5464 |
|
pos, regs, stop, |
5465 |
|
NULL, 0, NULL, 0, NULL, NULL); |
5466 |
|
else |
5467 |
|
# endif |
5468 |
|
result = byte_re_match_2_internal (bufp, string1, size1, string2, size2, |
5469 |
|
pos, regs, stop); |
5470 |
|
|
5471 |
|
#ifndef REGEX_MALLOC |
5472 |
|
# ifdef C_ALLOCA |
5473 |
alloca (0); |
alloca (0); |
5474 |
|
# endif |
5475 |
|
#endif |
5476 |
return result; |
return result; |
5477 |
} |
} |
5478 |
|
#ifdef _LIBC |
5479 |
|
weak_alias (__re_match_2, re_match_2) |
5480 |
|
#endif |
5481 |
|
|
5482 |
|
#endif /* not INSIDE_RECURSION */ |
5483 |
|
|
5484 |
|
#ifdef INSIDE_RECURSION |
5485 |
|
|
5486 |
|
#ifdef WCHAR |
5487 |
|
|
5488 |
|
/* This check the substring (from 0, to length) of the multibyte string, |
5489 |
|
to which offset_buffer correspond. And count how many wchar_t_characters |
5490 |
|
the substring occupy. We use offset_buffer to optimization. |
5491 |
|
See convert_mbs_to_wcs. */ |
5492 |
|
|
5493 |
|
static int |
5494 |
|
count_mbs_length (int *offset_buffer, int length) |
5495 |
|
{ |
5496 |
|
int upper, lower; |
5497 |
|
|
5498 |
|
/* Check whether the size is valid. */ |
5499 |
|
if (length < 0) |
5500 |
|
return -1; |
5501 |
|
|
5502 |
|
if (offset_buffer == NULL) |
5503 |
|
return 0; |
5504 |
|
|
5505 |
|
/* If there are no multibyte character, offset_buffer[i] == i. |
5506 |
|
Optmize for this case. */ |
5507 |
|
if (offset_buffer[length] == length) |
5508 |
|
return length; |
5509 |
|
|
5510 |
|
/* Set up upper with length. (because for all i, offset_buffer[i] >= i) */ |
5511 |
|
upper = length; |
5512 |
|
lower = 0; |
5513 |
|
|
5514 |
|
while (true) |
5515 |
|
{ |
5516 |
|
int middle = (lower + upper) / 2; |
5517 |
|
if (middle == lower || middle == upper) |
5518 |
|
break; |
5519 |
|
if (offset_buffer[middle] > length) |
5520 |
|
upper = middle; |
5521 |
|
else if (offset_buffer[middle] < length) |
5522 |
|
lower = middle; |
5523 |
|
else |
5524 |
|
return middle; |
5525 |
|
} |
5526 |
|
|
5527 |
|
return -1; |
5528 |
|
} |
5529 |
|
#endif /* WCHAR */ |
5530 |
|
|
5531 |
/* This is a separate function so that we can force an alloca cleanup |
/* This is a separate function so that we can force an alloca cleanup |
5532 |
afterwards. */ |
afterwards. */ |
5533 |
|
#ifdef WCHAR |
5534 |
|
static int |
5535 |
|
wcs_re_match_2_internal (struct re_pattern_buffer *bufp, |
5536 |
|
const char *cstring1, int csize1, |
5537 |
|
const char *cstring2, int csize2, |
5538 |
|
int pos, |
5539 |
|
struct re_registers *regs, |
5540 |
|
int stop, |
5541 |
|
/* string1 == string2 == NULL means |
5542 |
|
string1/2, size1/2 and mbs_offset1/2 need |
5543 |
|
setting up in this function. */ |
5544 |
|
/* We need wchar_t * buffers corresponding to |
5545 |
|
cstring1, cstring2. */ |
5546 |
|
wchar_t *string1, int size1, |
5547 |
|
wchar_t *string2, int size2, |
5548 |
|
/* Offset buffer for optimization. See |
5549 |
|
convert_mbs_to_wc. */ |
5550 |
|
int *mbs_offset1, |
5551 |
|
int *mbs_offset2) |
5552 |
|
#else /* BYTE */ |
5553 |
static int |
static int |
5554 |
re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop) |
byte_re_match_2_internal (struct re_pattern_buffer *bufp, |
5555 |
struct re_pattern_buffer *bufp; |
const char *string1, int size1, |
5556 |
const char *string1, *string2; |
const char *string2, int size2, |
5557 |
int size1, size2; |
int pos, |
5558 |
int pos; |
struct re_registers *regs, |
5559 |
struct re_registers *regs; |
int stop) |
5560 |
int stop; |
#endif /* BYTE */ |
5561 |
{ |
{ |
5562 |
/* General temporaries. */ |
/* General temporaries. */ |
5563 |
int mcnt; |
int mcnt; |
5564 |
unsigned char *p1; |
UCHAR_T *p1; |
5565 |
|
#ifdef WCHAR |
5566 |
|
/* They hold whether each wchar_t is binary data or not. */ |
5567 |
|
char *is_binary = NULL; |
5568 |
|
/* If true, we can't free string1/2, mbs_offset1/2. */ |
5569 |
|
int cant_free_wcs_buf = 1; |
5570 |
|
#endif /* WCHAR */ |
5571 |
|
|
5572 |
/* Just past the end of the corresponding string. */ |
/* Just past the end of the corresponding string. */ |
5573 |
const char *end1, *end2; |
const CHAR_T *end1, *end2; |
5574 |
|
|
5575 |
/* Pointers into string1 and string2, just past the last characters in |
/* Pointers into string1 and string2, just past the last characters in |
5576 |
each to consider matching. */ |
each to consider matching. */ |
5577 |
const char *end_match_1, *end_match_2; |
const CHAR_T *end_match_1, *end_match_2; |
5578 |
|
|
5579 |
/* Where we are in the data, and the end of the current string. */ |
/* Where we are in the data, and the end of the current string. */ |
5580 |
const char *d, *dend; |
const CHAR_T *d, *dend; |
5581 |
|
|
5582 |
/* Where we are in the pattern, and the end of the pattern. */ |
/* Where we are in the pattern, and the end of the pattern. */ |
5583 |
unsigned char *p = bufp->buffer; |
#ifdef WCHAR |
5584 |
register unsigned char *pend = p + bufp->used; |
UCHAR_T *pattern, *p; |
5585 |
|
register UCHAR_T *pend; |
5586 |
|
#else /* BYTE */ |
5587 |
|
UCHAR_T *p = bufp->buffer; |
5588 |
|
register UCHAR_T *pend = p + bufp->used; |
5589 |
|
#endif /* WCHAR */ |
5590 |
|
|
5591 |
/* Mark the opcode just after a start_memory, so we can test for an |
/* Mark the opcode just after a start_memory, so we can test for an |
5592 |
empty subpattern when we get to the stop_memory. */ |
empty subpattern when we get to the stop_memory. */ |
5593 |
unsigned char *just_past_start_mem = 0; |
UCHAR_T *just_past_start_mem = 0; |
5594 |
|
|
5595 |
/* We use this to map every character in the string. */ |
/* We use this to map every character in the string. */ |
5596 |
char *translate = bufp->translate; |
RE_TRANSLATE_TYPE translate = bufp->translate; |
5597 |
|
|
5598 |
/* Failure point stack. Each place that can handle a failure further |
/* Failure point stack. Each place that can handle a failure further |
5599 |
down the line pushes a failure point on this stack. It consists of |
down the line pushes a failure point on this stack. It consists of |
5605 |
a ``dummy''; if a failure happens and the failure point is a dummy, |
a ``dummy''; if a failure happens and the failure point is a dummy, |
5606 |
it gets discarded and the next next one is tried. */ |
it gets discarded and the next next one is tried. */ |
5607 |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */ |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */ |
5608 |
fail_stack_type fail_stack; |
PREFIX(fail_stack_type) fail_stack; |
5609 |
#endif |
#endif |
5610 |
#ifdef DEBUG |
#ifdef DEBUG |
5611 |
static unsigned failure_id = 0; |
static unsigned failure_id; |
5612 |
unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0; |
unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0; |
5613 |
#endif |
#endif |
5614 |
|
|
5615 |
|
#ifdef REL_ALLOC |
5616 |
|
/* This holds the pointer to the failure stack, when |
5617 |
|
it is allocated relocatably. */ |
5618 |
|
fail_stack_elt_t *failure_stack_ptr; |
5619 |
|
#endif |
5620 |
|
|
5621 |
/* We fill all the registers internally, independent of what we |
/* We fill all the registers internally, independent of what we |
5622 |
return, for use in backreferences. The number here includes |
return, for use in backreferences. The number here includes |
5623 |
an element for register zero. */ |
an element for register zero. */ |
5624 |
unsigned num_regs = bufp->re_nsub + 1; |
size_t num_regs = bufp->re_nsub + 1; |
5625 |
|
|
5626 |
/* The currently active registers. */ |
/* The currently active registers. */ |
5627 |
unsigned lowest_active_reg = NO_LOWEST_ACTIVE_REG; |
active_reg_t lowest_active_reg = NO_LOWEST_ACTIVE_REG; |
5628 |
unsigned highest_active_reg = NO_HIGHEST_ACTIVE_REG; |
active_reg_t highest_active_reg = NO_HIGHEST_ACTIVE_REG; |
5629 |
|
|
5630 |
/* Information on the contents of registers. These are pointers into |
/* Information on the contents of registers. These are pointers into |
5631 |
the input strings; they record just what was matched (on this |
the input strings; they record just what was matched (on this |
5635 |
stopped matching the regnum-th subexpression. (The zeroth register |
stopped matching the regnum-th subexpression. (The zeroth register |
5636 |
keeps track of what the whole pattern matches.) */ |
keeps track of what the whole pattern matches.) */ |
5637 |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ |
5638 |
const char **regstart, **regend; |
const CHAR_T **regstart, **regend; |
5639 |
#endif |
#endif |
5640 |
|
|
5641 |
/* If a group that's operated upon by a repetition operator fails to |
/* If a group that's operated upon by a repetition operator fails to |
5644 |
are when we last see its open-group operator. Similarly for a |
are when we last see its open-group operator. Similarly for a |
5645 |
register's end. */ |
register's end. */ |
5646 |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ |
5647 |
const char **old_regstart, **old_regend; |
const CHAR_T **old_regstart, **old_regend; |
5648 |
#endif |
#endif |
5649 |
|
|
5650 |
/* The is_active field of reg_info helps us keep track of which (possibly |
/* The is_active field of reg_info helps us keep track of which (possibly |
5654 |
subexpression. These two fields get reset each time through any |
subexpression. These two fields get reset each time through any |
5655 |
loop their register is in. */ |
loop their register is in. */ |
5656 |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */ |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global. */ |
5657 |
register_info_type *reg_info; |
PREFIX(register_info_type) *reg_info; |
5658 |
#endif |
#endif |
5659 |
|
|
5660 |
/* The following record the register info as found in the above |
/* The following record the register info as found in the above |
5661 |
variables when we find a match better than any we've seen before. |
variables when we find a match better than any we've seen before. |
5662 |
This happens as we backtrack through the failure points, which in |
This happens as we backtrack through the failure points, which in |
5663 |
turn happens only if we have not yet matched the entire string. */ |
turn happens only if we have not yet matched the entire string. */ |
5664 |
unsigned best_regs_set = false; |
unsigned best_regs_set = false; |
5665 |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ |
5666 |
const char **best_regstart, **best_regend; |
const CHAR_T **best_regstart, **best_regend; |
5667 |
#endif |
#endif |
5668 |
|
|
5669 |
/* Logically, this is `best_regend[0]'. But we don't want to have to |
/* Logically, this is `best_regend[0]'. But we don't want to have to |
5670 |
allocate space for that if we're not allocating space for anything |
allocate space for that if we're not allocating space for anything |
5671 |
else (see below). Also, we never need info about register 0 for |
else (see below). Also, we never need info about register 0 for |
5674 |
the end of the best match so far in a separate variable. We |
the end of the best match so far in a separate variable. We |
5675 |
initialize this to NULL so that when we backtrack the first time |
initialize this to NULL so that when we backtrack the first time |
5676 |
and need to test it, it's not garbage. */ |
and need to test it, it's not garbage. */ |
5677 |
const char *match_end = NULL; |
const CHAR_T *match_end = NULL; |
5678 |
|
|
5679 |
|
/* This helps SET_REGS_MATCHED avoid doing redundant work. */ |
5680 |
|
int set_regs_matched_done = 0; |
5681 |
|
|
5682 |
/* Used when we pop values we don't care about. */ |
/* Used when we pop values we don't care about. */ |
5683 |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ |
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ |
5684 |
const char **reg_dummy; |
const CHAR_T **reg_dummy; |
5685 |
register_info_type *reg_info_dummy; |
PREFIX(register_info_type) *reg_info_dummy; |
5686 |
#endif |
#endif |
5687 |
|
|
5688 |
#ifdef DEBUG |
#ifdef DEBUG |
5689 |
/* Counts the total number of registers pushed. */ |
/* Counts the total number of registers pushed. */ |
5690 |
unsigned num_regs_pushed = 0; |
unsigned num_regs_pushed = 0; |
5691 |
|
#endif |
5692 |
|
|
5693 |
|
/* Definitions for state transitions. More efficiently for gcc. */ |
5694 |
|
#ifdef __GNUC__ |
5695 |
|
# if defined HAVE_SUBTRACT_LOCAL_LABELS && defined SHARED |
5696 |
|
# define NEXT \ |
5697 |
|
do \ |
5698 |
|
{ \ |
5699 |
|
int offset; \ |
5700 |
|
const void *__unbounded ptr; \ |
5701 |
|
offset = (p == pend \ |
5702 |
|
? 0 : jmptable[SWITCH_ENUM_CAST ((re_opcode_t) *p++)]); \ |
5703 |
|
ptr = &&end_of_pattern + offset; \ |
5704 |
|
goto *ptr; \ |
5705 |
|
} \ |
5706 |
|
while (0) |
5707 |
|
# define REF(x) \ |
5708 |
|
&&label_##x - &&end_of_pattern |
5709 |
|
# define JUMP_TABLE_TYPE const int |
5710 |
|
# else |
5711 |
|
# define NEXT \ |
5712 |
|
do \ |
5713 |
|
{ \ |
5714 |
|
const void *__unbounded ptr; \ |
5715 |
|
ptr = (p == pend ? &&end_of_pattern \ |
5716 |
|
: jmptable[SWITCH_ENUM_CAST ((re_opcode_t) *p++)]); \ |
5717 |
|
goto *ptr; \ |
5718 |
|
} \ |
5719 |
|
while (0) |
5720 |
|
# define REF(x) \ |
5721 |
|
&&label_##x |
5722 |
|
# define JUMP_TABLE_TYPE const void *const |
5723 |
|
# endif |
5724 |
|
# define CASE(x) label_##x |
5725 |
|
static JUMP_TABLE_TYPE jmptable[] = |
5726 |
|
{ |
5727 |
|
REF (no_op), |
5728 |
|
REF (succeed), |
5729 |
|
REF (exactn), |
5730 |
|
# ifdef MBS_SUPPORT |
5731 |
|
REF (exactn_bin), |
5732 |
|
# endif |
5733 |
|
REF (anychar), |
5734 |
|
REF (charset), |
5735 |
|
REF (charset_not), |
5736 |
|
REF (start_memory), |
5737 |
|
REF (stop_memory), |
5738 |
|
REF (duplicate), |
5739 |
|
REF (begline), |
5740 |
|
REF (endline), |
5741 |
|
REF (begbuf), |
5742 |
|
REF (endbuf), |
5743 |
|
REF (jump), |
5744 |
|
REF (jump_past_alt), |
5745 |
|
REF (on_failure_jump), |
5746 |
|
REF (on_failure_keep_string_jump), |
5747 |
|
REF (pop_failure_jump), |
5748 |
|
REF (maybe_pop_jump), |
5749 |
|
REF (dummy_failure_jump), |
5750 |
|
REF (push_dummy_failure), |
5751 |
|
REF (succeed_n), |
5752 |
|
REF (jump_n), |
5753 |
|
REF (set_number_at), |
5754 |
|
REF (wordchar), |
5755 |
|
REF (notwordchar), |
5756 |
|
REF (wordbeg), |
5757 |
|
REF (wordend), |
5758 |
|
REF (wordbound), |
5759 |
|
REF (notwordbound) |
5760 |
|
# ifdef emacs |
5761 |
|
,REF (before_dot), |
5762 |
|
REF (at_dot), |
5763 |
|
REF (after_dot), |
5764 |
|
REF (syntaxspec), |
5765 |
|
REF (notsyntaxspec) |
5766 |
|
# endif |
5767 |
|
}; |
5768 |
|
#else |
5769 |
|
# define NEXT \ |
5770 |
|
break |
5771 |
|
# define CASE(x) \ |
5772 |
|
case x |
5773 |
#endif |
#endif |
5774 |
|
|
5775 |
DEBUG_PRINT1 ("\n\nEntering re_match_2.\n"); |
DEBUG_PRINT1 ("\n\nEntering re_match_2.\n"); |
5776 |
|
|
5777 |
INIT_FAIL_STACK (); |
INIT_FAIL_STACK (); |
5778 |
|
|
5779 |
#ifdef MATCH_MAY_ALLOCATE |
#ifdef MATCH_MAY_ALLOCATE |
5780 |
/* Do not bother to initialize all the register variables if there are |
/* Do not bother to initialize all the register variables if there are |
5781 |
no groups in the pattern, as it takes a fair amount of time. If |
no groups in the pattern, as it takes a fair amount of time. If |
5784 |
array indexing. We should fix this. */ |
array indexing. We should fix this. */ |
5785 |
if (bufp->re_nsub) |
if (bufp->re_nsub) |
5786 |
{ |
{ |
5787 |
regstart = REGEX_TALLOC (num_regs, const char *); |
regstart = REGEX_TALLOC (num_regs, const CHAR_T *); |
5788 |
regend = REGEX_TALLOC (num_regs, const char *); |
regend = REGEX_TALLOC (num_regs, const CHAR_T *); |
5789 |
old_regstart = REGEX_TALLOC (num_regs, const char *); |
old_regstart = REGEX_TALLOC (num_regs, const CHAR_T *); |
5790 |
old_regend = REGEX_TALLOC (num_regs, const char *); |
old_regend = REGEX_TALLOC (num_regs, const CHAR_T *); |
5791 |
best_regstart = REGEX_TALLOC (num_regs, const char *); |
best_regstart = REGEX_TALLOC (num_regs, const CHAR_T *); |
5792 |
best_regend = REGEX_TALLOC (num_regs, const char *); |
best_regend = REGEX_TALLOC (num_regs, const CHAR_T *); |
5793 |
reg_info = REGEX_TALLOC (num_regs, register_info_type); |
reg_info = REGEX_TALLOC (num_regs, PREFIX(register_info_type)); |
5794 |
reg_dummy = REGEX_TALLOC (num_regs, const char *); |
reg_dummy = REGEX_TALLOC (num_regs, const CHAR_T *); |
5795 |
reg_info_dummy = REGEX_TALLOC (num_regs, register_info_type); |
reg_info_dummy = REGEX_TALLOC (num_regs, PREFIX(register_info_type)); |
5796 |
|
|
5797 |
if (!(regstart && regend && old_regstart && old_regend && reg_info |
if (!(regstart && regend && old_regstart && old_regend && reg_info |
5798 |
&& best_regstart && best_regend && reg_dummy && reg_info_dummy)) |
&& best_regstart && best_regend && reg_dummy && reg_info_dummy)) |
5799 |
{ |
{ |
5800 |
FREE_VARIABLES (); |
FREE_VARIABLES (); |
5801 |
return -2; |
return -2; |
5802 |
} |
} |
5803 |
} |
} |
|
#if defined (REGEX_MALLOC) |
|
5804 |
else |
else |
5805 |
{ |
{ |
5806 |
/* We must initialize all our variables to NULL, so that |
/* We must initialize all our variables to NULL, so that |
5807 |
`FREE_VARIABLES' doesn't try to free them. */ |
`FREE_VARIABLES' doesn't try to free them. */ |
5808 |
regstart = regend = old_regstart = old_regend = best_regstart |
regstart = regend = old_regstart = old_regend = best_regstart |
5809 |
= best_regend = reg_dummy = NULL; |
= best_regend = reg_dummy = NULL; |
5810 |
reg_info = reg_info_dummy = (register_info_type *) NULL; |
reg_info = reg_info_dummy = (PREFIX(register_info_type) *) NULL; |
5811 |
} |
} |
|
#endif /* REGEX_MALLOC */ |
|
5812 |
#endif /* MATCH_MAY_ALLOCATE */ |
#endif /* MATCH_MAY_ALLOCATE */ |
5813 |
|
|
5814 |
/* The starting position is bogus. */ |
/* The starting position is bogus. */ |
5815 |
|
#ifdef WCHAR |
5816 |
|
if (pos < 0 || pos > csize1 + csize2) |
5817 |
|
#else /* BYTE */ |
5818 |
if (pos < 0 || pos > size1 + size2) |
if (pos < 0 || pos > size1 + size2) |
5819 |
|
#endif |
5820 |
{ |
{ |
5821 |
FREE_VARIABLES (); |
FREE_VARIABLES (); |
5822 |
return -1; |
return -1; |
5823 |
} |
} |
5824 |
|
|
5825 |
|
#ifdef WCHAR |
5826 |
|
/* Allocate wchar_t array for string1 and string2 and |
5827 |
|
fill them with converted string. */ |
5828 |
|
if (string1 == NULL && string2 == NULL) |
5829 |
|
{ |
5830 |
|
/* We need seting up buffers here. */ |
5831 |
|
|
5832 |
|
/* We must free wcs buffers in this function. */ |
5833 |
|
cant_free_wcs_buf = 0; |
5834 |
|
|
5835 |
|
if (csize1 != 0) |
5836 |
|
{ |
5837 |
|
string1 = REGEX_TALLOC (csize1 + 1, CHAR_T); |
5838 |
|
mbs_offset1 = REGEX_TALLOC (csize1 + 1, int); |
5839 |
|
is_binary = REGEX_TALLOC (csize1 + 1, char); |
5840 |
|
if (!string1 || !mbs_offset1 || !is_binary) |
5841 |
|
{ |
5842 |
|
FREE_VAR (string1); |
5843 |
|
FREE_VAR (mbs_offset1); |
5844 |
|
FREE_VAR (is_binary); |
5845 |
|
return -2; |
5846 |
|
} |
5847 |
|
} |
5848 |
|
if (csize2 != 0) |
5849 |
|
{ |
5850 |
|
string2 = REGEX_TALLOC (csize2 + 1, CHAR_T); |
5851 |
|
mbs_offset2 = REGEX_TALLOC (csize2 + 1, int); |
5852 |
|
is_binary = REGEX_TALLOC (csize2 + 1, char); |
5853 |
|
if (!string2 || !mbs_offset2 || !is_binary) |
5854 |
|
{ |
5855 |
|
FREE_VAR (string1); |
5856 |
|
FREE_VAR (mbs_offset1); |
5857 |
|
FREE_VAR (string2); |
5858 |
|
FREE_VAR (mbs_offset2); |
5859 |
|
FREE_VAR (is_binary); |
5860 |
|
return -2; |
5861 |
|
} |
5862 |
|
size2 = convert_mbs_to_wcs(string2, cstring2, csize2, |
5863 |
|
mbs_offset2, is_binary); |
5864 |
|
string2[size2] = L'\0'; /* for a sentinel */ |
5865 |
|
FREE_VAR (is_binary); |
5866 |
|
} |
5867 |
|
} |
5868 |
|
|
5869 |
|
/* We need to cast pattern to (wchar_t*), because we casted this compiled |
5870 |
|
pattern to (char*) in regex_compile. */ |
5871 |
|
p = pattern = (CHAR_T*)bufp->buffer; |
5872 |
|
pend = (CHAR_T*)(bufp->buffer + bufp->used); |
5873 |
|
|
5874 |
|
#endif /* WCHAR */ |
5875 |
|
|
5876 |
/* Initialize subexpression text positions to -1 to mark ones that no |
/* Initialize subexpression text positions to -1 to mark ones that no |
5877 |
start_memory/stop_memory has been seen for. Also initialize the |
start_memory/stop_memory has been seen for. Also initialize the |
5878 |
register information struct. */ |
register information struct. */ |
5879 |
for (mcnt = 1; mcnt < num_regs; mcnt++) |
for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++) |
5880 |
{ |
{ |
5881 |
regstart[mcnt] = regend[mcnt] |
regstart[mcnt] = regend[mcnt] |
5882 |
= old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE; |
= old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE; |
5883 |
|
|
5884 |
REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE; |
REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE; |
5885 |
IS_ACTIVE (reg_info[mcnt]) = 0; |
IS_ACTIVE (reg_info[mcnt]) = 0; |
5886 |
MATCHED_SOMETHING (reg_info[mcnt]) = 0; |
MATCHED_SOMETHING (reg_info[mcnt]) = 0; |
5887 |
EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0; |
EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0; |
5888 |
} |
} |
5889 |
|
|
5890 |
/* We move `string1' into `string2' if the latter's empty -- but not if |
/* We move `string1' into `string2' if the latter's empty -- but not if |
5891 |
`string1' is null. */ |
`string1' is null. */ |
5892 |
if (size2 == 0 && string1 != NULL) |
if (size2 == 0 && string1 != NULL) |
5895 |
size2 = size1; |
size2 = size1; |
5896 |
string1 = 0; |
string1 = 0; |
5897 |
size1 = 0; |
size1 = 0; |
5898 |
|
#ifdef WCHAR |
5899 |
|
mbs_offset2 = mbs_offset1; |
5900 |
|
csize2 = csize1; |
5901 |
|
mbs_offset1 = NULL; |
5902 |
|
csize1 = 0; |
5903 |
|
#endif |
5904 |
} |
} |
5905 |
end1 = string1 + size1; |
end1 = string1 + size1; |
5906 |
end2 = string2 + size2; |
end2 = string2 + size2; |
5907 |
|
|
5908 |
/* Compute where to stop matching, within the two strings. */ |
/* Compute where to stop matching, within the two strings. */ |
5909 |
|
#ifdef WCHAR |
5910 |
|
if (stop <= csize1) |
5911 |
|
{ |
5912 |
|
mcnt = count_mbs_length(mbs_offset1, stop); |
5913 |
|
end_match_1 = string1 + mcnt; |
5914 |
|
end_match_2 = string2; |
5915 |
|
} |
5916 |
|
else |
5917 |
|
{ |
5918 |
|
if (stop > csize1 + csize2) |
5919 |
|
stop = csize1 + csize2; |
5920 |
|
end_match_1 = end1; |
5921 |
|
mcnt = count_mbs_length(mbs_offset2, stop-csize1); |
5922 |
|
end_match_2 = string2 + mcnt; |
5923 |
|
} |
5924 |
|
if (mcnt < 0) |
5925 |
|
{ /* count_mbs_length return error. */ |
5926 |
|
FREE_VARIABLES (); |
5927 |
|
return -1; |
5928 |
|
} |
5929 |
|
#else |
5930 |
if (stop <= size1) |
if (stop <= size1) |
5931 |
{ |
{ |
5932 |
end_match_1 = string1 + stop; |
end_match_1 = string1 + stop; |
5937 |
end_match_1 = end1; |
end_match_1 = end1; |
5938 |
end_match_2 = string2 + stop - size1; |
end_match_2 = string2 + stop - size1; |
5939 |
} |
} |
5940 |
|
#endif /* WCHAR */ |
5941 |
|
|
5942 |
/* `p' scans through the pattern as `d' scans through the data. |
/* `p' scans through the pattern as `d' scans through the data. |
5943 |
`dend' is the end of the input string that `d' points within. `d' |
`dend' is the end of the input string that `d' points within. `d' |
5944 |
is advanced into the following input string whenever necessary, but |
is advanced into the following input string whenever necessary, but |
5945 |
this happens before fetching; therefore, at the beginning of the |
this happens before fetching; therefore, at the beginning of the |
5946 |
loop, `d' can be pointing at the end of a string, but it cannot |
loop, `d' can be pointing at the end of a string, but it cannot |
5947 |
equal `string2'. */ |
equal `string2'. */ |
5948 |
|
#ifdef WCHAR |
5949 |
|
if (size1 > 0 && pos <= csize1) |
5950 |
|
{ |
5951 |
|
mcnt = count_mbs_length(mbs_offset1, pos); |
5952 |
|
d = string1 + mcnt; |
5953 |
|
dend = end_match_1; |
5954 |
|
} |
5955 |
|
else |
5956 |
|
{ |
5957 |
|
mcnt = count_mbs_length(mbs_offset2, pos-csize1); |
5958 |
|
d = string2 + mcnt; |
5959 |
|
dend = end_match_2; |
5960 |
|
} |
5961 |
|
|
5962 |
|
if (mcnt < 0) |
5963 |
|
{ /* count_mbs_length return error. */ |
5964 |
|
FREE_VARIABLES (); |
5965 |
|
return -1; |
5966 |
|
} |
5967 |
|
#else |
5968 |
if (size1 > 0 && pos <= size1) |
if (size1 > 0 && pos <= size1) |
5969 |
{ |
{ |
5970 |
d = string1 + pos; |
d = string1 + pos; |
5975 |
d = string2 + pos - size1; |
d = string2 + pos - size1; |
5976 |
dend = end_match_2; |
dend = end_match_2; |
5977 |
} |
} |
5978 |
|
#endif /* WCHAR */ |
5979 |
|
|
5980 |
DEBUG_PRINT1 ("The compiled pattern is: "); |
DEBUG_PRINT1 ("The compiled pattern is:\n"); |
5981 |
DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend); |
DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend); |
5982 |
DEBUG_PRINT1 ("The string to match is: `"); |
DEBUG_PRINT1 ("The string to match is: `"); |
5983 |
DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2); |
DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2); |
5984 |
DEBUG_PRINT1 ("'\n"); |
DEBUG_PRINT1 ("'\n"); |
5985 |
|
|
5986 |
/* This loops over pattern commands. It exits by returning from the |
/* This loops over pattern commands. It exits by returning from the |
5987 |
function if the match is complete, or it drops through if the match |
function if the match is complete, or it drops through if the match |
5988 |
fails at this starting point in the input data. */ |
fails at this starting point in the input data. */ |
5989 |
for (;;) |
for (;;) |
5990 |
{ |
{ |
5991 |
|
#ifdef _LIBC |
5992 |
|
DEBUG_PRINT2 ("\n%p: ", p); |
5993 |
|
#else |
5994 |
DEBUG_PRINT2 ("\n0x%x: ", p); |
DEBUG_PRINT2 ("\n0x%x: ", p); |
5995 |
|
#endif |
5996 |
|
|
5997 |
|
#ifdef __GNUC__ |
5998 |
|
NEXT; |
5999 |
|
#else |
6000 |
if (p == pend) |
if (p == pend) |
6001 |
{ /* End of pattern means we might have succeeded. */ |
#endif |
6002 |
DEBUG_PRINT1 ("end of pattern ... "); |
{ |
6003 |
|
#ifdef __GNUC__ |
6004 |
|
end_of_pattern: |
6005 |
|
#endif |
6006 |
|
/* End of pattern means we might have succeeded. */ |
6007 |
|
DEBUG_PRINT1 ("end of pattern ... "); |
6008 |
|
|
6009 |
/* If we haven't matched the entire string, and we want the |
/* If we haven't matched the entire string, and we want the |
6010 |
longest match, try backtracking. */ |
longest match, try backtracking. */ |
6011 |
if (d != end_match_2) |
if (d != end_match_2) |
6012 |
{ |
{ |
6013 |
/* 1 if this match ends in the same string (string1 or string2) |
/* 1 if this match ends in the same string (string1 or string2) |
6014 |
as the best previous match. */ |
as the best previous match. */ |
6015 |
boolean same_str_p = (FIRST_STRING_P (match_end) |
boolean same_str_p = (FIRST_STRING_P (match_end) |
6016 |
== MATCHING_IN_FIRST_STRING); |
== MATCHING_IN_FIRST_STRING); |
6017 |
/* 1 if this match is the best seen so far. */ |
/* 1 if this match is the best seen so far. */ |
6018 |
boolean best_match_p; |
boolean best_match_p; |
6024 |
else |
else |
6025 |
best_match_p = !MATCHING_IN_FIRST_STRING; |
best_match_p = !MATCHING_IN_FIRST_STRING; |
6026 |
|
|
6027 |
DEBUG_PRINT1 ("backtracking.\n"); |
DEBUG_PRINT1 ("backtracking.\n"); |
|
|
|
|
if (!FAIL_STACK_EMPTY ()) |
|
|
{ /* More failure points to try. */ |
|
6028 |
|
|
6029 |
/* If exceeds best match so far, save it. */ |
if (!FAIL_STACK_EMPTY ()) |
6030 |
if (!best_regs_set || best_match_p) |
{ /* More failure points to try. */ |
|
{ |
|
|
best_regs_set = true; |
|
|
match_end = d; |
|
|
|
|
|
DEBUG_PRINT1 ("\nSAVING match as best so far.\n"); |
|
|
|
|
|
for (mcnt = 1; mcnt < num_regs; mcnt++) |
|
|
{ |
|
|
best_regstart[mcnt] = regstart[mcnt]; |
|
|
best_regend[mcnt] = regend[mcnt]; |
|
|
} |
|
|
} |
|
|
goto fail; |
|
|
} |
|
6031 |
|
|
6032 |
/* If no failure points, don't restore garbage. And if |
/* If exceeds best match so far, save it. */ |
6033 |
last match is real best match, don't restore second |
if (!best_regs_set || best_match_p) |
6034 |
best one. */ |
{ |
6035 |
else if (best_regs_set && !best_match_p) |
best_regs_set = true; |
6036 |
{ |
match_end = d; |
6037 |
restore_best_regs: |
|
6038 |
/* Restore best match. It may happen that `dend == |
DEBUG_PRINT1 ("\nSAVING match as best so far.\n"); |
6039 |
end_match_1' while the restored d is in string2. |
|
6040 |
For example, the pattern `x.*y.*z' against the |
for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++) |
6041 |
strings `x-' and `y-z-', if the two strings are |
{ |
6042 |
not consecutive in memory. */ |
best_regstart[mcnt] = regstart[mcnt]; |
6043 |
DEBUG_PRINT1 ("Restoring best registers.\n"); |
best_regend[mcnt] = regend[mcnt]; |
6044 |
|
} |
6045 |
d = match_end; |
} |
6046 |
dend = ((d >= string1 && d <= end1) |
goto fail; |
6047 |
? end_match_1 : end_match_2); |
} |
6048 |
|
|
6049 |
|
/* If no failure points, don't restore garbage. And if |
6050 |
|
last match is real best match, don't restore second |
6051 |
|
best one. */ |
6052 |
|
else if (best_regs_set && !best_match_p) |
6053 |
|
{ |
6054 |
|
restore_best_regs: |
6055 |
|
/* Restore best match. It may happen that `dend == |
6056 |
|
end_match_1' while the restored d is in string2. |
6057 |
|
For example, the pattern `x.*y.*z' against the |
6058 |
|
strings `x-' and `y-z-', if the two strings are |
6059 |
|
not consecutive in memory. */ |
6060 |
|
DEBUG_PRINT1 ("Restoring best registers.\n"); |
6061 |
|
|
6062 |
|
d = match_end; |
6063 |
|
dend = ((d >= string1 && d <= end1) |
6064 |
|
? end_match_1 : end_match_2); |
6065 |
|
|
6066 |
for (mcnt = 1; mcnt < num_regs; mcnt++) |
for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++) |
6067 |
{ |
{ |
6068 |
regstart[mcnt] = best_regstart[mcnt]; |
regstart[mcnt] = best_regstart[mcnt]; |
6069 |
regend[mcnt] = best_regend[mcnt]; |
regend[mcnt] = best_regend[mcnt]; |
6070 |
} |
} |
6071 |
} |
} |
6072 |
} /* d != end_match_2 */ |
} /* d != end_match_2 */ |
|
|
|
|
DEBUG_PRINT1 ("Accepting match.\n"); |
|
6073 |
|
|
6074 |
/* If caller wants register contents data back, do it. */ |
succeed_label: |
6075 |
if (regs && !bufp->no_sub) |
DEBUG_PRINT1 ("Accepting match.\n"); |
6076 |
|
/* If caller wants register contents data back, do it. */ |
6077 |
|
if (regs && !bufp->no_sub) |
6078 |
{ |
{ |
6079 |
/* Have the register data arrays been allocated? */ |
/* Have the register data arrays been allocated? */ |
6080 |
if (bufp->regs_allocated == REGS_UNALLOCATED) |
if (bufp->regs_allocated == REGS_UNALLOCATED) |
6081 |
{ /* No. So allocate them with malloc. We need one |
{ /* No. So allocate them with malloc. We need one |
6082 |
extra element beyond `num_regs' for the `-1' marker |
extra element beyond `num_regs' for the `-1' marker |
6083 |
GNU code uses. */ |
GNU code uses. */ |
6084 |
regs->num_regs = MAX (RE_NREGS, num_regs + 1); |
regs->num_regs = MAX (RE_NREGS, num_regs + 1); |
6085 |
regs->start = TALLOC (regs->num_regs, regoff_t); |
regs->start = TALLOC (regs->num_regs, regoff_t); |
6086 |
regs->end = TALLOC (regs->num_regs, regoff_t); |
regs->end = TALLOC (regs->num_regs, regoff_t); |
6087 |
if (regs->start == NULL || regs->end == NULL) |
if (regs->start == NULL || regs->end == NULL) |
6088 |
return -2; |
{ |
6089 |
bufp->regs_allocated = REGS_REALLOCATE; |
FREE_VARIABLES (); |
6090 |
} |
return -2; |
6091 |
else if (bufp->regs_allocated == REGS_REALLOCATE) |
} |
6092 |
{ /* Yes. If we need more elements than were already |
bufp->regs_allocated = REGS_REALLOCATE; |
6093 |
allocated, reallocate them. If we need fewer, just |
} |
6094 |
leave it alone. */ |
else if (bufp->regs_allocated == REGS_REALLOCATE) |
6095 |
if (regs->num_regs < num_regs + 1) |
{ /* Yes. If we need more elements than were already |
6096 |
{ |
allocated, reallocate them. If we need fewer, just |
6097 |
regs->num_regs = num_regs + 1; |
leave it alone. */ |
6098 |
RETALLOC (regs->start, regs->num_regs, regoff_t); |
if (regs->num_regs < num_regs + 1) |
6099 |
RETALLOC (regs->end, regs->num_regs, regoff_t); |
{ |
6100 |
if (regs->start == NULL || regs->end == NULL) |
regs->num_regs = num_regs + 1; |
6101 |
return -2; |
RETALLOC (regs->start, regs->num_regs, regoff_t); |
6102 |
} |
RETALLOC (regs->end, regs->num_regs, regoff_t); |
6103 |
} |
if (regs->start == NULL || regs->end == NULL) |
6104 |
else |
{ |
6105 |
|
FREE_VARIABLES (); |
6106 |
|
return -2; |
6107 |
|
} |
6108 |
|
} |
6109 |
|
} |
6110 |
|
else |
6111 |
{ |
{ |
6112 |
/* These braces fend off a "empty body in an else-statement" |
/* These braces fend off a "empty body in an else-statement" |
6113 |
warning under GCC when assert expands to nothing. */ |
warning under GCC when assert expands to nothing. */ |
6114 |
assert (bufp->regs_allocated == REGS_FIXED); |
assert (bufp->regs_allocated == REGS_FIXED); |
6115 |
} |
} |
6116 |
|
|
6117 |
/* Convert the pointer data in `regstart' and `regend' to |
/* Convert the pointer data in `regstart' and `regend' to |
6118 |
indices. Register zero has to be set differently, |
indices. Register zero has to be set differently, |
6119 |
since we haven't kept track of any info for it. */ |
since we haven't kept track of any info for it. */ |
6120 |
if (regs->num_regs > 0) |
if (regs->num_regs > 0) |
6121 |
{ |
{ |
6122 |
regs->start[0] = pos; |
regs->start[0] = pos; |
6123 |
regs->end[0] = (MATCHING_IN_FIRST_STRING |
#ifdef WCHAR |
6124 |
|
if (MATCHING_IN_FIRST_STRING) |
6125 |
|
regs->end[0] = (mbs_offset1 != NULL ? |
6126 |
|
mbs_offset1[d-string1] : 0); |
6127 |
|
else |
6128 |
|
regs->end[0] = csize1 + (mbs_offset2 != NULL |
6129 |
|
? mbs_offset2[d-string2] : 0); |
6130 |
|
#else |
6131 |
|
regs->end[0] = (MATCHING_IN_FIRST_STRING |
6132 |
? ((regoff_t) (d - string1)) |
? ((regoff_t) (d - string1)) |
6133 |
: ((regoff_t) (d - string2 + size1))); |
: ((regoff_t) (d - string2 + size1))); |
6134 |
} |
#endif /* WCHAR */ |
6135 |
|
} |
6136 |
/* Go through the first `min (num_regs, regs->num_regs)' |
|
6137 |
registers, since that is all we initialized. */ |
/* Go through the first `min (num_regs, regs->num_regs)' |
6138 |
for (mcnt = 1; mcnt < MIN (num_regs, regs->num_regs); mcnt++) |
registers, since that is all we initialized. */ |
6139 |
|
for (mcnt = 1; (unsigned) mcnt < MIN (num_regs, regs->num_regs); |
6140 |
|
mcnt++) |
6141 |
{ |
{ |
6142 |
if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt])) |
if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt])) |
6143 |
regs->start[mcnt] = regs->end[mcnt] = -1; |
regs->start[mcnt] = regs->end[mcnt] = -1; |
6144 |
else |
else |
6145 |
{ |
{ |
6146 |
regs->start[mcnt] |
regs->start[mcnt] |
6147 |
= (regoff_t) POINTER_TO_OFFSET (regstart[mcnt]); |
= (regoff_t) POINTER_TO_OFFSET (regstart[mcnt]); |
6148 |
regs->end[mcnt] |
regs->end[mcnt] |
6149 |
= (regoff_t) POINTER_TO_OFFSET (regend[mcnt]); |
= (regoff_t) POINTER_TO_OFFSET (regend[mcnt]); |
6150 |
} |
} |
6151 |
} |
} |
6152 |
|
|
6153 |
/* If the regs structure we return has more elements than |
/* If the regs structure we return has more elements than |
6154 |
were in the pattern, set the extra elements to -1. If |
were in the pattern, set the extra elements to -1. If |
6155 |
we (re)allocated the registers, this is the case, |
we (re)allocated the registers, this is the case, |
6156 |
because we always allocate enough to have at least one |
because we always allocate enough to have at least one |
6157 |
-1 at the end. */ |
-1 at the end. */ |
6158 |
for (mcnt = num_regs; mcnt < regs->num_regs; mcnt++) |
for (mcnt = num_regs; (unsigned) mcnt < regs->num_regs; mcnt++) |
6159 |
regs->start[mcnt] = regs->end[mcnt] = -1; |
regs->start[mcnt] = regs->end[mcnt] = -1; |
6160 |
} /* regs && !bufp->no_sub */ |
} /* regs && !bufp->no_sub */ |
6161 |
|
|
6162 |
FREE_VARIABLES (); |
DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n", |
6163 |
DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n", |
nfailure_points_pushed, nfailure_points_popped, |
6164 |
nfailure_points_pushed, nfailure_points_popped, |
nfailure_points_pushed - nfailure_points_popped); |
6165 |
nfailure_points_pushed - nfailure_points_popped); |
DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed); |
6166 |
DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed); |
|
6167 |
|
#ifdef WCHAR |
6168 |
mcnt = d - pos - (MATCHING_IN_FIRST_STRING |
if (MATCHING_IN_FIRST_STRING) |
6169 |
? string1 |
mcnt = mbs_offset1 != NULL ? mbs_offset1[d-string1] : 0; |
6170 |
: string2 - size1); |
else |
6171 |
|
mcnt = (mbs_offset2 != NULL ? mbs_offset2[d-string2] : 0) + |
6172 |
|
csize1; |
6173 |
|
mcnt -= pos; |
6174 |
|
#else |
6175 |
|
mcnt = d - pos - (MATCHING_IN_FIRST_STRING |
6176 |
|
? string1 : string2 - size1); |
6177 |
|
#endif /* WCHAR */ |
6178 |
|
|
6179 |
DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt); |
DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt); |
6180 |
|
|
6181 |
return mcnt; |
FREE_VARIABLES (); |
6182 |
} |
return mcnt; |
6183 |
|
} |
6184 |
|
|
6185 |
|
#ifndef __GNUC__ |
6186 |
/* Otherwise match next pattern command. */ |
/* Otherwise match next pattern command. */ |
6187 |
#ifdef SWITCH_ENUM_BUG |
switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++)) |
|
switch ((int) ((re_opcode_t) *p++)) |
|
|
#else |
|
|
switch ((re_opcode_t) *p++) |
|
|
#endif |
|
6188 |
{ |
{ |
6189 |
|
#endif |
6190 |
/* Ignore these. Used to ignore the n of succeed_n's which |
/* Ignore these. Used to ignore the n of succeed_n's which |
6191 |
currently have n == 0. */ |
currently have n == 0. */ |
6192 |
case no_op: |
CASE (no_op): |
6193 |
DEBUG_PRINT1 ("EXECUTING no_op.\n"); |
DEBUG_PRINT1 ("EXECUTING no_op.\n"); |
6194 |
break; |
NEXT; |
6195 |
|
|
6196 |
|
CASE (succeed): |
6197 |
|
DEBUG_PRINT1 ("EXECUTING succeed.\n"); |
6198 |
|
goto succeed_label; |
6199 |
|
|
6200 |
/* Match the next n pattern characters exactly. The following |
/* Match the next n pattern characters exactly. The following |
6201 |
byte in the pattern defines n, and the n bytes after that |
byte in the pattern defines n, and the n bytes after that |
6202 |
are the characters to match. */ |
are the characters to match. */ |
6203 |
case exactn: |
CASE (exactn): |
6204 |
|
#ifdef MBS_SUPPORT |
6205 |
|
CASE (exactn_bin): |
6206 |
|
#endif |
6207 |
mcnt = *p++; |
mcnt = *p++; |
6208 |
DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt); |
DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt); |
6209 |
|
|
6214 |
do |
do |
6215 |
{ |
{ |
6216 |
PREFETCH (); |
PREFETCH (); |
6217 |
if (translate[(unsigned char) *d++] != (char) *p++) |
#ifdef WCHAR |
6218 |
|
if (*d <= 0xff) |
6219 |
|
{ |
6220 |
|
if ((UCHAR_T) translate[(unsigned char) *d++] |
6221 |
|
!= (UCHAR_T) *p++) |
6222 |
|
goto fail; |
6223 |
|
} |
6224 |
|
else |
6225 |
|
{ |
6226 |
|
if (*d++ != (CHAR_T) *p++) |
6227 |
|
goto fail; |
6228 |
|
} |
6229 |
|
#else |
6230 |
|
if ((UCHAR_T) translate[(unsigned char) *d++] |
6231 |
|
!= (UCHAR_T) *p++) |
6232 |
goto fail; |
goto fail; |
6233 |
|
#endif /* WCHAR */ |
6234 |
} |
} |
6235 |
while (--mcnt); |
while (--mcnt); |
6236 |
} |
} |
6239 |
do |
do |
6240 |
{ |
{ |
6241 |
PREFETCH (); |
PREFETCH (); |
6242 |
if (*d++ != (char) *p++) goto fail; |
if (*d++ != (CHAR_T) *p++) goto fail; |
6243 |
} |
} |
6244 |
while (--mcnt); |
while (--mcnt); |
6245 |
} |
} |
6246 |
SET_REGS_MATCHED (); |
SET_REGS_MATCHED (); |
6247 |
break; |
NEXT; |
6248 |
|
|
6249 |
|
|
6250 |
/* Match any character except possibly a newline or a null. */ |
/* Match any character except possibly a newline or a null. */ |
6251 |
case anychar: |
CASE (anychar): |
6252 |
DEBUG_PRINT1 ("EXECUTING anychar.\n"); |
DEBUG_PRINT1 ("EXECUTING anychar.\n"); |
6253 |
|
|
6254 |
PREFETCH (); |
PREFETCH (); |
6258 |
goto fail; |
goto fail; |
6259 |
|
|
6260 |
SET_REGS_MATCHED (); |
SET_REGS_MATCHED (); |
6261 |
DEBUG_PRINT2 (" Matched `%d'.\n", *d); |
DEBUG_PRINT2 (" Matched `%ld'.\n", (long int) *d); |
6262 |
d++; |
d++; |
6263 |
break; |
NEXT; |
6264 |
|
|
6265 |
|
|
6266 |
case charset: |
CASE (charset): |
6267 |
case charset_not: |
CASE (charset_not): |
6268 |
{ |
{ |
6269 |
register unsigned char c; |
register UCHAR_T c; |
6270 |
|
#ifdef WCHAR |
6271 |
|
unsigned int i, char_class_length, coll_symbol_length, |
6272 |
|
equiv_class_length, ranges_length, chars_length, length; |
6273 |
|
CHAR_T *workp, *workp2, *charset_top; |
6274 |
|
#define WORK_BUFFER_SIZE 128 |
6275 |
|
CHAR_T str_buf[WORK_BUFFER_SIZE]; |
6276 |
|
# ifdef _LIBC |
6277 |
|
uint32_t nrules; |
6278 |
|
# endif /* _LIBC */ |
6279 |
|
#endif /* WCHAR */ |
6280 |
boolean not = (re_opcode_t) *(p - 1) == charset_not; |
boolean not = (re_opcode_t) *(p - 1) == charset_not; |
6281 |
|
|
6282 |
DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : ""); |
DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : ""); |
|
|
|
6283 |
PREFETCH (); |
PREFETCH (); |
6284 |
c = TRANSLATE (*d); /* The character to match. */ |
c = TRANSLATE (*d); /* The character to match. */ |
6285 |
|
#ifdef WCHAR |
6286 |
|
# ifdef _LIBC |
6287 |
|
nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES); |
6288 |
|
# endif /* _LIBC */ |
6289 |
|
charset_top = p - 1; |
6290 |
|
char_class_length = *p++; |
6291 |
|
coll_symbol_length = *p++; |
6292 |
|
equiv_class_length = *p++; |
6293 |
|
ranges_length = *p++; |
6294 |
|
chars_length = *p++; |
6295 |
|
/* p points charset[6], so the address of the next instruction |
6296 |
|
(charset[l+m+n+2o+k+p']) equals p[l+m+n+2*o+p'], |
6297 |
|
where l=length of char_classes, m=length of collating_symbol, |
6298 |
|
n=equivalence_class, o=length of char_range, |
6299 |
|
p'=length of character. */ |
6300 |
|
workp = p; |
6301 |
|
/* Update p to indicate the next instruction. */ |
6302 |
|
p += char_class_length + coll_symbol_length+ equiv_class_length + |
6303 |
|
2*ranges_length + chars_length; |
6304 |
|
|
6305 |
|
/* match with char_class? */ |
6306 |
|
for (i = 0; i < char_class_length ; i += CHAR_CLASS_SIZE) |
6307 |
|
{ |
6308 |
|
wctype_t wctype; |
6309 |
|
uintptr_t alignedp = ((uintptr_t)workp |
6310 |
|
+ __alignof__(wctype_t) - 1) |
6311 |
|
& ~(uintptr_t)(__alignof__(wctype_t) - 1); |
6312 |
|
wctype = *((wctype_t*)alignedp); |
6313 |
|
workp += CHAR_CLASS_SIZE; |
6314 |
|
if (iswctype((wint_t)c, wctype)) |
6315 |
|
goto char_set_matched; |
6316 |
|
} |
6317 |
|
|
6318 |
|
/* match with collating_symbol? */ |
6319 |
|
# ifdef _LIBC |
6320 |
|
if (nrules != 0) |
6321 |
|
{ |
6322 |
|
const unsigned char *extra = (const unsigned char *) |
6323 |
|
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB); |
6324 |
|
|
6325 |
|
for (workp2 = workp + coll_symbol_length ; workp < workp2 ; |
6326 |
|
workp++) |
6327 |
|
{ |
6328 |
|
int32_t *wextra; |
6329 |
|
wextra = (int32_t*)(extra + *workp++); |
6330 |
|
for (i = 0; i < *wextra; ++i) |
6331 |
|
if (TRANSLATE(d[i]) != wextra[1 + i]) |
6332 |
|
break; |
6333 |
|
|
6334 |
|
if (i == *wextra) |
6335 |
|
{ |
6336 |
|
/* Update d, however d will be incremented at |
6337 |
|
char_set_matched:, we decrement d here. */ |
6338 |
|
d += i - 1; |
6339 |
|
goto char_set_matched; |
6340 |
|
} |
6341 |
|
} |
6342 |
|
} |
6343 |
|
else /* (nrules == 0) */ |
6344 |
|
# endif |
6345 |
|
/* If we can't look up collation data, we use wcscoll |
6346 |
|
instead. */ |
6347 |
|
{ |
6348 |
|
for (workp2 = workp + coll_symbol_length ; workp < workp2 ;) |
6349 |
|
{ |
6350 |
|
const CHAR_T *backup_d = d, *backup_dend = dend; |
6351 |
|
length = wcslen (workp); |
6352 |
|
|
6353 |
|
/* If wcscoll(the collating symbol, whole string) > 0, |
6354 |
|
any substring of the string never match with the |
6355 |
|
collating symbol. */ |
6356 |
|
if (wcscoll (workp, d) > 0) |
6357 |
|
{ |
6358 |
|
workp += length + 1; |
6359 |
|
continue; |
6360 |
|
} |
6361 |
|
|
6362 |
|
/* First, we compare the collating symbol with |
6363 |
|
the first character of the string. |
6364 |
|
If it don't match, we add the next character to |
6365 |
|
the compare buffer in turn. */ |
6366 |
|
for (i = 0 ; i < WORK_BUFFER_SIZE-1 ; i++, d++) |
6367 |
|
{ |
6368 |
|
int match; |
6369 |
|
if (d == dend) |
6370 |
|
{ |
6371 |
|
if (dend == end_match_2) |
6372 |
|
break; |
6373 |
|
d = string2; |
6374 |
|
dend = end_match_2; |
6375 |
|
} |
6376 |
|
|
6377 |
|
/* add next character to the compare buffer. */ |
6378 |
|
str_buf[i] = TRANSLATE(*d); |
6379 |
|
str_buf[i+1] = '\0'; |
6380 |
|
|
6381 |
|
match = wcscoll (workp, str_buf); |
6382 |
|
if (match == 0) |
6383 |
|
goto char_set_matched; |
6384 |
|
|
6385 |
|
if (match < 0) |
6386 |
|
/* (str_buf > workp) indicate (str_buf + X > workp), |
6387 |
|
because for all X (str_buf + X > str_buf). |
6388 |
|
So we don't need continue this loop. */ |
6389 |
|
break; |
6390 |
|
|
6391 |
|
/* Otherwise(str_buf < workp), |
6392 |
|
(str_buf+next_character) may equals (workp). |
6393 |
|
So we continue this loop. */ |
6394 |
|
} |
6395 |
|
/* not matched */ |
6396 |
|
d = backup_d; |
6397 |
|
dend = backup_dend; |
6398 |
|
workp += length + 1; |
6399 |
|
} |
6400 |
|
} |
6401 |
|
/* match with equivalence_class? */ |
6402 |
|
# ifdef _LIBC |
6403 |
|
if (nrules != 0) |
6404 |
|
{ |
6405 |
|
const CHAR_T *backup_d = d, *backup_dend = dend; |
6406 |
|
/* Try to match the equivalence class against |
6407 |
|
those known to the collate implementation. */ |
6408 |
|
const int32_t *table; |
6409 |
|
const int32_t *weights; |
6410 |
|
const int32_t *extra; |
6411 |
|
const int32_t *indirect; |
6412 |
|
int32_t idx, idx2; |
6413 |
|
wint_t *cp; |
6414 |
|
size_t len; |
6415 |
|
|
6416 |
|
/* This #include defines a local function! */ |
6417 |
|
# include <locale/weightwc.h> |
6418 |
|
|
6419 |
|
table = (const int32_t *) |
6420 |
|
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEWC); |
6421 |
|
weights = (const wint_t *) |
6422 |
|
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTWC); |
6423 |
|
extra = (const wint_t *) |
6424 |
|
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAWC); |
6425 |
|
indirect = (const int32_t *) |
6426 |
|
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTWC); |
6427 |
|
|
6428 |
|
/* Write 1 collating element to str_buf, and |
6429 |
|
get its index. */ |
6430 |
|
idx2 = 0; |
6431 |
|
|
6432 |
|
for (i = 0 ; idx2 == 0 && i < WORK_BUFFER_SIZE - 1; i++) |
6433 |
|
{ |
6434 |
|
cp = (wint_t*)str_buf; |
6435 |
|
if (d == dend) |
6436 |
|
{ |
6437 |
|
if (dend == end_match_2) |
6438 |
|
break; |
6439 |
|
d = string2; |
6440 |
|
dend = end_match_2; |
6441 |
|
} |
6442 |
|
str_buf[i] = TRANSLATE(*(d+i)); |
6443 |
|
str_buf[i+1] = '\0'; /* sentinel */ |
6444 |
|
idx2 = findidx ((const wint_t**)&cp); |
6445 |
|
} |
6446 |
|
|
6447 |
|
/* Update d, however d will be incremented at |
6448 |
|
char_set_matched:, we decrement d here. */ |
6449 |
|
d = backup_d + ((wchar_t*)cp - (wchar_t*)str_buf - 1); |
6450 |
|
if (d >= dend) |
6451 |
|
{ |
6452 |
|
if (dend == end_match_2) |
6453 |
|
d = dend; |
6454 |
|
else |
6455 |
|
{ |
6456 |
|
d = string2; |
6457 |
|
dend = end_match_2; |
6458 |
|
} |
6459 |
|
} |
6460 |
|
|
6461 |
|
len = weights[idx2]; |
6462 |
|
|
6463 |
|
for (workp2 = workp + equiv_class_length ; workp < workp2 ; |
6464 |
|
workp++) |
6465 |
|
{ |
6466 |
|
idx = (int32_t)*workp; |
6467 |
|
/* We already checked idx != 0 in regex_compile. */ |
6468 |
|
|
6469 |
|
if (idx2 != 0 && len == weights[idx]) |
6470 |
|
{ |
6471 |
|
int cnt = 0; |
6472 |
|
while (cnt < len && (weights[idx + 1 + cnt] |
6473 |
|
== weights[idx2 + 1 + cnt])) |
6474 |
|
++cnt; |
6475 |
|
|
6476 |
|
if (cnt == len) |
6477 |
|
goto char_set_matched; |
6478 |
|
} |
6479 |
|
} |
6480 |
|
/* not matched */ |
6481 |
|
d = backup_d; |
6482 |
|
dend = backup_dend; |
6483 |
|
} |
6484 |
|
else /* (nrules == 0) */ |
6485 |
|
# endif |
6486 |
|
/* If we can't look up collation data, we use wcscoll |
6487 |
|
instead. */ |
6488 |
|
{ |
6489 |
|
for (workp2 = workp + equiv_class_length ; workp < workp2 ;) |
6490 |
|
{ |
6491 |
|
const CHAR_T *backup_d = d, *backup_dend = dend; |
6492 |
|
length = wcslen (workp); |
6493 |
|
|
6494 |
|
/* If wcscoll(the collating symbol, whole string) > 0, |
6495 |
|
any substring of the string never match with the |
6496 |
|
collating symbol. */ |
6497 |
|
if (wcscoll (workp, d) > 0) |
6498 |
|
{ |
6499 |
|
workp += length + 1; |
6500 |
|
break; |
6501 |
|
} |
6502 |
|
|
6503 |
|
/* First, we compare the equivalence class with |
6504 |
|
the first character of the string. |
6505 |
|
If it don't match, we add the next character to |
6506 |
|
the compare buffer in turn. */ |
6507 |
|
for (i = 0 ; i < WORK_BUFFER_SIZE - 1 ; i++, d++) |
6508 |
|
{ |
6509 |
|
int match; |
6510 |
|
if (d == dend) |
6511 |
|
{ |
6512 |
|
if (dend == end_match_2) |
6513 |
|
break; |
6514 |
|
d = string2; |
6515 |
|
dend = end_match_2; |
6516 |
|
} |
6517 |
|
|
6518 |
|
/* add next character to the compare buffer. */ |
6519 |
|
str_buf[i] = TRANSLATE(*d); |
6520 |
|
str_buf[i+1] = '\0'; |
6521 |
|
|
6522 |
|
match = wcscoll (workp, str_buf); |
6523 |
|
|
6524 |
|
if (match == 0) |
6525 |
|
goto char_set_matched; |
6526 |
|
|
6527 |
|
if (match < 0) |
6528 |
|
/* (str_buf > workp) indicate (str_buf + X > workp), |
6529 |
|
because for all X (str_buf + X > str_buf). |
6530 |
|
So we don't need continue this loop. */ |
6531 |
|
break; |
6532 |
|
|
6533 |
|
/* Otherwise(str_buf < workp), |
6534 |
|
(str_buf+next_character) may equals (workp). |
6535 |
|
So we continue this loop. */ |
6536 |
|
} |
6537 |
|
/* not matched */ |
6538 |
|
d = backup_d; |
6539 |
|
dend = backup_dend; |
6540 |
|
workp += length + 1; |
6541 |
|
} |
6542 |
|
} |
6543 |
|
|
6544 |
|
/* match with char_range? */ |
6545 |
|
# ifdef _LIBC |
6546 |
|
if (nrules != 0) |
6547 |
|
{ |
6548 |
|
uint32_t collseqval; |
6549 |
|
const char *collseq = (const char *) |
6550 |
|
_NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQWC); |
6551 |
|
|
6552 |
|
collseqval = collseq_table_lookup (collseq, c); |
6553 |
|
|
6554 |
|
for (; workp < p - chars_length ;) |
6555 |
|
{ |
6556 |
|
uint32_t start_val, end_val; |
6557 |
|
|
6558 |
|
/* We already compute the collation sequence value |
6559 |
|
of the characters (or collating symbols). */ |
6560 |
|
start_val = (uint32_t) *workp++; /* range_start */ |
6561 |
|
end_val = (uint32_t) *workp++; /* range_end */ |
6562 |
|
|
6563 |
|
if (start_val <= collseqval && collseqval <= end_val) |
6564 |
|
goto char_set_matched; |
6565 |
|
} |
6566 |
|
} |
6567 |
|
else |
6568 |
|
# endif |
6569 |
|
{ |
6570 |
|
/* We set range_start_char at str_buf[0], range_end_char |
6571 |
|
at str_buf[4], and compared char at str_buf[2]. */ |
6572 |
|
str_buf[1] = 0; |
6573 |
|
str_buf[2] = c; |
6574 |
|
str_buf[3] = 0; |
6575 |
|
str_buf[5] = 0; |
6576 |
|
for (; workp < p - chars_length ;) |
6577 |
|
{ |
6578 |
|
wchar_t *range_start_char, *range_end_char; |
6579 |
|
|
6580 |
|
/* match if (range_start_char <= c <= range_end_char). */ |
6581 |
|
|
6582 |
|
/* If range_start(or end) < 0, we assume -range_start(end) |
6583 |
|
is the offset of the collating symbol which is specified |
6584 |
|
as the character of the range start(end). */ |
6585 |
|
|
6586 |
|
/* range_start */ |
6587 |
|
if (*workp < 0) |
6588 |
|
range_start_char = charset_top - (*workp++); |
6589 |
|
else |
6590 |
|
{ |
6591 |
|
str_buf[0] = *workp++; |
6592 |
|
range_start_char = str_buf; |
6593 |
|
} |
6594 |
|
|
6595 |
|
/* range_end */ |
6596 |
|
if (*workp < 0) |
6597 |
|
range_end_char = charset_top - (*workp++); |
6598 |
|
else |
6599 |
|
{ |
6600 |
|
str_buf[4] = *workp++; |
6601 |
|
range_end_char = str_buf + 4; |
6602 |
|
} |
6603 |
|
|
6604 |
|
if (wcscoll (range_start_char, str_buf+2) <= 0 |
6605 |
|
&& wcscoll (str_buf+2, range_end_char) <= 0) |
6606 |
|
goto char_set_matched; |
6607 |
|
} |
6608 |
|
} |
6609 |
|
|
6610 |
|
/* match with char? */ |
6611 |
|
for (; workp < p ; workp++) |
6612 |
|
if (c == *workp) |
6613 |
|
goto char_set_matched; |
6614 |
|
|
6615 |
|
not = !not; |
6616 |
|
|
6617 |
|
char_set_matched: |
6618 |
|
if (not) goto fail; |
6619 |
|
#else |
6620 |
/* Cast to `unsigned' instead of `unsigned char' in case the |
/* Cast to `unsigned' instead of `unsigned char' in case the |
6621 |
bit list is a full 32 bytes long. */ |
bit list is a full 32 bytes long. */ |
6622 |
if (c < (unsigned) (*p * BYTEWIDTH) |
if (c < (unsigned) (*p * BYTEWIDTH) |
6626 |
p += 1 + *p; |
p += 1 + *p; |
6627 |
|
|
6628 |
if (!not) goto fail; |
if (!not) goto fail; |
6629 |
|
#undef WORK_BUFFER_SIZE |
6630 |
|
#endif /* WCHAR */ |
6631 |
SET_REGS_MATCHED (); |
SET_REGS_MATCHED (); |
6632 |
d++; |
d++; |
6633 |
break; |
NEXT; |
6634 |
} |
} |
6635 |
|
|
6636 |
|
|
6639 |
number of groups inner to this one in the next. The text |
number of groups inner to this one in the next. The text |
6640 |
matched within the group is recorded (in the internal |
matched within the group is recorded (in the internal |
6641 |
registers data structure) under the register number. */ |
registers data structure) under the register number. */ |
6642 |
case start_memory: |
CASE (start_memory): |
6643 |
DEBUG_PRINT3 ("EXECUTING start_memory %d (%d):\n", *p, p[1]); |
DEBUG_PRINT3 ("EXECUTING start_memory %ld (%ld):\n", |
6644 |
|
(long int) *p, (long int) p[1]); |
6645 |
|
|
6646 |
/* Find out if this group can match the empty string. */ |
/* Find out if this group can match the empty string. */ |
6647 |
p1 = p; /* To send to group_match_null_string_p. */ |
p1 = p; /* To send to group_match_null_string_p. */ |
6648 |
|
|
6649 |
if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE) |
if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE) |
6650 |
REG_MATCH_NULL_STRING_P (reg_info[*p]) |
REG_MATCH_NULL_STRING_P (reg_info[*p]) |
6651 |
= group_match_null_string_p (&p1, pend, reg_info); |
= PREFIX(group_match_null_string_p) (&p1, pend, reg_info); |
6652 |
|
|
6653 |
/* Save the position in the string where we were the last time |
/* Save the position in the string where we were the last time |
6654 |
we were at this open-group operator in case the group is |
we were at this open-group operator in case the group is |
6658 |
old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p]) |
old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p]) |
6659 |
? REG_UNSET (regstart[*p]) ? d : regstart[*p] |
? REG_UNSET (regstart[*p]) ? d : regstart[*p] |
6660 |
: regstart[*p]; |
: regstart[*p]; |
6661 |
DEBUG_PRINT2 (" old_regstart: %d\n", |
DEBUG_PRINT2 (" old_regstart: %d\n", |
6662 |
POINTER_TO_OFFSET (old_regstart[*p])); |
POINTER_TO_OFFSET (old_regstart[*p])); |
6663 |
|
|
6664 |
regstart[*p] = d; |
regstart[*p] = d; |
6666 |
|
|
6667 |
IS_ACTIVE (reg_info[*p]) = 1; |
IS_ACTIVE (reg_info[*p]) = 1; |
6668 |
MATCHED_SOMETHING (reg_info[*p]) = 0; |
MATCHED_SOMETHING (reg_info[*p]) = 0; |
6669 |
|
|
6670 |
|
/* Clear this whenever we change the register activity status. */ |
6671 |
|
set_regs_matched_done = 0; |
6672 |
|
|
6673 |
/* This is the new highest active register. */ |
/* This is the new highest active register. */ |
6674 |
highest_active_reg = *p; |
highest_active_reg = *p; |
6675 |
|
|
6676 |
/* If nothing was active before, this is the new lowest active |
/* If nothing was active before, this is the new lowest active |
6677 |
register. */ |
register. */ |
6678 |
if (lowest_active_reg == NO_LOWEST_ACTIVE_REG) |
if (lowest_active_reg == NO_LOWEST_ACTIVE_REG) |
6681 |
/* Move past the register number and inner group count. */ |
/* Move past the register number and inner group count. */ |
6682 |
p += 2; |
p += 2; |
6683 |
just_past_start_mem = p; |
just_past_start_mem = p; |
6684 |
break; |
|
6685 |
|
NEXT; |
6686 |
|
|
6687 |
|
|
6688 |
/* The stop_memory opcode represents the end of a group. Its |
/* The stop_memory opcode represents the end of a group. Its |
6689 |
arguments are the same as start_memory's: the register |
arguments are the same as start_memory's: the register |
6690 |
number, and the number of inner groups. */ |
number, and the number of inner groups. */ |
6691 |
case stop_memory: |
CASE (stop_memory): |
6692 |
DEBUG_PRINT3 ("EXECUTING stop_memory %d (%d):\n", *p, p[1]); |
DEBUG_PRINT3 ("EXECUTING stop_memory %ld (%ld):\n", |
6693 |
|
(long int) *p, (long int) p[1]); |
6694 |
|
|
6695 |
/* We need to save the string position the last time we were at |
/* We need to save the string position the last time we were at |
6696 |
this close-group operator in case the group is operated |
this close-group operator in case the group is operated |
6697 |
upon by a repetition operator, e.g., with `((a*)*(b*)*)*' |
upon by a repetition operator, e.g., with `((a*)*(b*)*)*' |
6700 |
old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p]) |
old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p]) |
6701 |
? REG_UNSET (regend[*p]) ? d : regend[*p] |
? REG_UNSET (regend[*p]) ? d : regend[*p] |
6702 |
: regend[*p]; |
: regend[*p]; |
6703 |
DEBUG_PRINT2 (" old_regend: %d\n", |
DEBUG_PRINT2 (" old_regend: %d\n", |
6704 |
POINTER_TO_OFFSET (old_regend[*p])); |
POINTER_TO_OFFSET (old_regend[*p])); |
6705 |
|
|
6706 |
regend[*p] = d; |
regend[*p] = d; |
6708 |
|
|
6709 |
/* This register isn't active anymore. */ |
/* This register isn't active anymore. */ |
6710 |
IS_ACTIVE (reg_info[*p]) = 0; |
IS_ACTIVE (reg_info[*p]) = 0; |
6711 |
|
|
6712 |
|
/* Clear this whenever we change the register activity status. */ |
6713 |
|
set_regs_matched_done = 0; |
6714 |
|
|
6715 |
/* If this was the only register active, nothing is active |
/* If this was the only register active, nothing is active |
6716 |
anymore. */ |
anymore. */ |
6717 |
if (lowest_active_reg == highest_active_reg) |
if (lowest_active_reg == highest_active_reg) |
6724 |
it isn't necessarily one less than now: consider |
it isn't necessarily one less than now: consider |
6725 |
(a(b)c(d(e)f)g). When group 3 ends, after the f), the |
(a(b)c(d(e)f)g). When group 3 ends, after the f), the |
6726 |
new highest active register is 1. */ |
new highest active register is 1. */ |
6727 |
unsigned char r = *p - 1; |
UCHAR_T r = *p - 1; |
6728 |
while (r > 0 && !IS_ACTIVE (reg_info[r])) |
while (r > 0 && !IS_ACTIVE (reg_info[r])) |
6729 |
r--; |
r--; |
6730 |
|
|
6731 |
/* If we end up at register zero, that means that we saved |
/* If we end up at register zero, that means that we saved |
6732 |
the registers as the result of an `on_failure_jump', not |
the registers as the result of an `on_failure_jump', not |
6733 |
a `start_memory', and we jumped to past the innermost |
a `start_memory', and we jumped to past the innermost |
6743 |
else |
else |
6744 |
highest_active_reg = r; |
highest_active_reg = r; |
6745 |
} |
} |
6746 |
|
|
6747 |
/* If just failed to match something this time around with a |
/* If just failed to match something this time around with a |
6748 |
group that's operated on by a repetition operator, try to |
group that's operated on by a repetition operator, try to |
6749 |
force exit from the ``loop'', and restore the register |
force exit from the ``loop'', and restore the register |
6751 |
last match. */ |
last match. */ |
6752 |
if ((!MATCHED_SOMETHING (reg_info[*p]) |
if ((!MATCHED_SOMETHING (reg_info[*p]) |
6753 |
|| just_past_start_mem == p - 1) |
|| just_past_start_mem == p - 1) |
6754 |
&& (p + 2) < pend) |
&& (p + 2) < pend) |
6755 |
{ |
{ |
6756 |
boolean is_a_jump_n = false; |
boolean is_a_jump_n = false; |
6757 |
|
|
6758 |
p1 = p + 2; |
p1 = p + 2; |
6759 |
mcnt = 0; |
mcnt = 0; |
6760 |
switch ((re_opcode_t) *p1++) |
switch ((re_opcode_t) *p1++) |
6767 |
case dummy_failure_jump: |
case dummy_failure_jump: |
6768 |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
6769 |
if (is_a_jump_n) |
if (is_a_jump_n) |
6770 |
p1 += 2; |
p1 += OFFSET_ADDRESS_SIZE; |
6771 |
break; |
break; |
6772 |
|
|
6773 |
default: |
default: |
6774 |
/* do nothing */ ; |
/* do nothing */ ; |
6775 |
} |
} |
6776 |
p1 += mcnt; |
p1 += mcnt; |
6777 |
|
|
6778 |
/* If the next operation is a jump backwards in the pattern |
/* If the next operation is a jump backwards in the pattern |
6779 |
to an on_failure_jump right before the start_memory |
to an on_failure_jump right before the start_memory |
6780 |
corresponding to this stop_memory, exit from the loop |
corresponding to this stop_memory, exit from the loop |
6781 |
by forcing a failure after pushing on the stack the |
by forcing a failure after pushing on the stack the |
6782 |
on_failure_jump's jump in the pattern, and d. */ |
on_failure_jump's jump in the pattern, and d. */ |
6783 |
if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump |
if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump |
6784 |
&& (re_opcode_t) p1[3] == start_memory && p1[4] == *p) |
&& (re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == start_memory |
6785 |
|
&& p1[2+OFFSET_ADDRESS_SIZE] == *p) |
6786 |
{ |
{ |
6787 |
/* If this group ever matched anything, then restore |
/* If this group ever matched anything, then restore |
6788 |
what its registers were before trying this last |
what its registers were before trying this last |
6789 |
failed match, e.g., with `(a*)*b' against `ab' for |
failed match, e.g., with `(a*)*b' against `ab' for |
6790 |
regstart[1], and, e.g., with `((a*)*(b*)*)*' |
regstart[1], and, e.g., with `((a*)*(b*)*)*' |
6791 |
against `aba' for regend[3]. |
against `aba' for regend[3]. |
6792 |
|
|
6793 |
Also restore the registers for inner groups for, |
Also restore the registers for inner groups for, |
6794 |
e.g., `((a*)(b*))*' against `aba' (register 3 would |
e.g., `((a*)(b*))*' against `aba' (register 3 would |
6795 |
otherwise get trashed). */ |
otherwise get trashed). */ |
6796 |
|
|
6797 |
if (EVER_MATCHED_SOMETHING (reg_info[*p])) |
if (EVER_MATCHED_SOMETHING (reg_info[*p])) |
6798 |
{ |
{ |
6799 |
unsigned r; |
unsigned r; |
6800 |
|
|
6801 |
EVER_MATCHED_SOMETHING (reg_info[*p]) = 0; |
EVER_MATCHED_SOMETHING (reg_info[*p]) = 0; |
6802 |
|
|
6803 |
/* Restore this and inner groups' (if any) registers. */ |
/* Restore this and inner groups' (if any) registers. */ |
6804 |
for (r = *p; r < *p + *(p + 1); r++) |
for (r = *p; r < (unsigned) *p + (unsigned) *(p + 1); |
6805 |
|
r++) |
6806 |
{ |
{ |
6807 |
regstart[r] = old_regstart[r]; |
regstart[r] = old_regstart[r]; |
6808 |
|
|
6809 |
/* xx why this test? */ |
/* xx why this test? */ |
6810 |
if ((int) old_regend[r] >= (int) regstart[r]) |
if (old_regend[r] >= regstart[r]) |
6811 |
regend[r] = old_regend[r]; |
regend[r] = old_regend[r]; |
6812 |
} |
} |
6813 |
} |
} |
6814 |
p1++; |
p1++; |
6815 |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
6818 |
goto fail; |
goto fail; |
6819 |
} |
} |
6820 |
} |
} |
6821 |
|
|
6822 |
/* Move past the register number and the inner group count. */ |
/* Move past the register number and the inner group count. */ |
6823 |
p += 2; |
p += 2; |
6824 |
break; |
NEXT; |
6825 |
|
|
6826 |
|
|
6827 |
/* \<digit> has been turned into a `duplicate' command which is |
/* \<digit> has been turned into a `duplicate' command which is |
6828 |
followed by the numeric value of <digit> as the register number. */ |
followed by the numeric value of <digit> as the register number. */ |
6829 |
case duplicate: |
CASE (duplicate): |
6830 |
{ |
{ |
6831 |
register const char *d2, *dend2; |
register const CHAR_T *d2, *dend2; |
6832 |
int regno = *p++; /* Get which register to match against. */ |
int regno = *p++; /* Get which register to match against. */ |
6833 |
DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno); |
DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno); |
6834 |
|
|
6835 |
/* Can't back reference a group which we've never matched. */ |
/* Can't back reference a group which we've never matched. */ |
6836 |
if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno])) |
if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno])) |
6837 |
goto fail; |
goto fail; |
6838 |
|
|
6839 |
/* Where in input to try to start matching. */ |
/* Where in input to try to start matching. */ |
6840 |
d2 = regstart[regno]; |
d2 = regstart[regno]; |
6841 |
|
|
6842 |
/* Where to stop matching; if both the place to start and |
/* Where to stop matching; if both the place to start and |
6843 |
the place to stop matching are in the same string, then |
the place to stop matching are in the same string, then |
6844 |
set to the place to stop, otherwise, for now have to use |
set to the place to stop, otherwise, for now have to use |
6845 |
the end of the first string. */ |
the end of the first string. */ |
6846 |
|
|
6847 |
dend2 = ((FIRST_STRING_P (regstart[regno]) |
dend2 = ((FIRST_STRING_P (regstart[regno]) |
6848 |
== FIRST_STRING_P (regend[regno])) |
== FIRST_STRING_P (regend[regno])) |
6849 |
? regend[regno] : end_match_1); |
? regend[regno] : end_match_1); |
6850 |
for (;;) |
for (;;) |
6868 |
|
|
6869 |
/* How many characters left in this segment to match. */ |
/* How many characters left in this segment to match. */ |
6870 |
mcnt = dend - d; |
mcnt = dend - d; |
6871 |
|
|
6872 |
/* Want how many consecutive characters we can match in |
/* Want how many consecutive characters we can match in |
6873 |
one shot, so, if necessary, adjust the count. */ |
one shot, so, if necessary, adjust the count. */ |
6874 |
if (mcnt > dend2 - d2) |
if (mcnt > dend2 - d2) |
6875 |
mcnt = dend2 - d2; |
mcnt = dend2 - d2; |
6876 |
|
|
6877 |
/* Compare that many; failure if mismatch, else move |
/* Compare that many; failure if mismatch, else move |
6878 |
past them. */ |
past them. */ |
6879 |
if (translate |
if (translate |
6880 |
? bcmp_translate (d, d2, mcnt, translate) |
? PREFIX(bcmp_translate) (d, d2, mcnt, translate) |
6881 |
: bcmp (d, d2, mcnt)) |
: memcmp (d, d2, mcnt*sizeof(UCHAR_T))) |
6882 |
goto fail; |
goto fail; |
6883 |
d += mcnt, d2 += mcnt; |
d += mcnt, d2 += mcnt; |
6884 |
|
|
6885 |
|
/* Do this because we've match some characters. */ |
6886 |
|
SET_REGS_MATCHED (); |
6887 |
} |
} |
6888 |
} |
} |
6889 |
break; |
NEXT; |
6890 |
|
|
6891 |
|
|
6892 |
/* begline matches the empty string at the beginning of the string |
/* begline matches the empty string at the beginning of the string |
6893 |
(unless `not_bol' is set in `bufp'), and, if |
(unless `not_bol' is set in `bufp'), and, if |
6894 |
`newline_anchor' is set, after newlines. */ |
`newline_anchor' is set, after newlines. */ |
6895 |
case begline: |
CASE (begline): |
6896 |
DEBUG_PRINT1 ("EXECUTING begline.\n"); |
DEBUG_PRINT1 ("EXECUTING begline.\n"); |
6897 |
|
|
6898 |
if (AT_STRINGS_BEG (d)) |
if (AT_STRINGS_BEG (d)) |
6899 |
{ |
{ |
6900 |
if (!bufp->not_bol) break; |
if (!bufp->not_bol) |
6901 |
|
{ |
6902 |
|
NEXT; |
6903 |
|
} |
6904 |
} |
} |
6905 |
else if (d[-1] == '\n' && bufp->newline_anchor) |
else if (d[-1] == '\n' && bufp->newline_anchor) |
6906 |
{ |
{ |
6907 |
break; |
NEXT; |
6908 |
} |
} |
6909 |
/* In all other cases, we fail. */ |
/* In all other cases, we fail. */ |
6910 |
goto fail; |
goto fail; |
6911 |
|
|
6912 |
|
|
6913 |
/* endline is the dual of begline. */ |
/* endline is the dual of begline. */ |
6914 |
case endline: |
CASE (endline): |
6915 |
DEBUG_PRINT1 ("EXECUTING endline.\n"); |
DEBUG_PRINT1 ("EXECUTING endline.\n"); |
6916 |
|
|
6917 |
if (AT_STRINGS_END (d)) |
if (AT_STRINGS_END (d)) |
6918 |
{ |
{ |
6919 |
if (!bufp->not_eol) break; |
if (!bufp->not_eol) |
6920 |
|
{ |
6921 |
|
NEXT; |
6922 |
|
} |
6923 |
} |
} |
6924 |
|
|
6925 |
/* We have to ``prefetch'' the next character. */ |
/* We have to ``prefetch'' the next character. */ |
6926 |
else if ((d == end1 ? *string2 : *d) == '\n' |
else if ((d == end1 ? *string2 : *d) == '\n' |
6927 |
&& bufp->newline_anchor) |
&& bufp->newline_anchor) |
6928 |
{ |
{ |
6929 |
break; |
NEXT; |
6930 |
} |
} |
6931 |
goto fail; |
goto fail; |
6932 |
|
|
6933 |
|
|
6934 |
/* Match at the very beginning of the data. */ |
/* Match at the very beginning of the data. */ |
6935 |
case begbuf: |
CASE (begbuf): |
6936 |
DEBUG_PRINT1 ("EXECUTING begbuf.\n"); |
DEBUG_PRINT1 ("EXECUTING begbuf.\n"); |
6937 |
if (AT_STRINGS_BEG (d)) |
if (AT_STRINGS_BEG (d)) |
6938 |
break; |
{ |
6939 |
|
NEXT; |
6940 |
|
} |
6941 |
goto fail; |
goto fail; |
6942 |
|
|
6943 |
|
|
6944 |
/* Match at the very end of the data. */ |
/* Match at the very end of the data. */ |
6945 |
case endbuf: |
CASE (endbuf): |
6946 |
DEBUG_PRINT1 ("EXECUTING endbuf.\n"); |
DEBUG_PRINT1 ("EXECUTING endbuf.\n"); |
6947 |
if (AT_STRINGS_END (d)) |
if (AT_STRINGS_END (d)) |
6948 |
break; |
{ |
6949 |
|
NEXT; |
6950 |
|
} |
6951 |
goto fail; |
goto fail; |
6952 |
|
|
6953 |
|
|
6959 |
then the . fails against the \n. But the next thing we want |
then the . fails against the \n. But the next thing we want |
6960 |
to do is match the \n against the \n; if we restored the |
to do is match the \n against the \n; if we restored the |
6961 |
string value, we would be back at the foo. |
string value, we would be back at the foo. |
6962 |
|
|
6963 |
Because this is used only in specific cases, we don't need to |
Because this is used only in specific cases, we don't need to |
6964 |
check all the things that `on_failure_jump' does, to make |
check all the things that `on_failure_jump' does, to make |
6965 |
sure the right things get saved on the stack. Hence we don't |
sure the right things get saved on the stack. Hence we don't |
6967 |
stack at all is that otherwise we would have to change |
stack at all is that otherwise we would have to change |
6968 |
`anychar's code to do something besides goto fail in this |
`anychar's code to do something besides goto fail in this |
6969 |
case; that seems worse than this. */ |
case; that seems worse than this. */ |
6970 |
case on_failure_keep_string_jump: |
CASE (on_failure_keep_string_jump): |
6971 |
DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump"); |
DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump"); |
6972 |
|
|
6973 |
EXTRACT_NUMBER_AND_INCR (mcnt, p); |
EXTRACT_NUMBER_AND_INCR (mcnt, p); |
6974 |
|
#ifdef _LIBC |
6975 |
|
DEBUG_PRINT3 (" %d (to %p):\n", mcnt, p + mcnt); |
6976 |
|
#else |
6977 |
DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt); |
DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt); |
6978 |
|
#endif |
6979 |
|
|
6980 |
PUSH_FAILURE_POINT (p + mcnt, NULL, -2); |
PUSH_FAILURE_POINT (p + mcnt, NULL, -2); |
6981 |
break; |
NEXT; |
6982 |
|
|
6983 |
|
|
6984 |
/* Uses of on_failure_jump: |
/* Uses of on_failure_jump: |
6985 |
|
|
6986 |
Each alternative starts with an on_failure_jump that points |
Each alternative starts with an on_failure_jump that points |
6987 |
to the beginning of the next alternative. Each alternative |
to the beginning of the next alternative. Each alternative |
6988 |
except the last ends with a jump that in effect jumps past |
except the last ends with a jump that in effect jumps past |
6993 |
Repeats start with an on_failure_jump that points past both |
Repeats start with an on_failure_jump that points past both |
6994 |
the repetition text and either the following jump or |
the repetition text and either the following jump or |
6995 |
pop_failure_jump back to this on_failure_jump. */ |
pop_failure_jump back to this on_failure_jump. */ |
6996 |
case on_failure_jump: |
CASE (on_failure_jump): |
6997 |
on_failure: |
on_failure: |
6998 |
DEBUG_PRINT1 ("EXECUTING on_failure_jump"); |
DEBUG_PRINT1 ("EXECUTING on_failure_jump"); |
6999 |
|
|
7000 |
EXTRACT_NUMBER_AND_INCR (mcnt, p); |
EXTRACT_NUMBER_AND_INCR (mcnt, p); |
7001 |
|
#ifdef _LIBC |
7002 |
|
DEBUG_PRINT3 (" %d (to %p)", mcnt, p + mcnt); |
7003 |
|
#else |
7004 |
DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt); |
DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt); |
7005 |
|
#endif |
7006 |
|
|
7007 |
/* If this on_failure_jump comes right before a group (i.e., |
/* If this on_failure_jump comes right before a group (i.e., |
7008 |
the original * applied to a group), save the information |
the original * applied to a group), save the information |
7009 |
for that group and all inner ones, so that if we fail back |
for that group and all inner ones, so that if we fail back |
7010 |
to this point, the group's information will be correct. |
to this point, the group's information will be correct. |
7011 |
For example, in \(a*\)*\1, we need the preceding group, |
For example, in \(a*\)*\1, we need the preceding group, |
7012 |
and in \(\(a*\)b*\)\2, we need the inner group. */ |
and in \(zz\(a*\)b*\)\2, we need the inner group. */ |
7013 |
|
|
7014 |
/* We can't use `p' to check ahead because we push |
/* We can't use `p' to check ahead because we push |
7015 |
a failure point to `p + mcnt' after we do this. */ |
a failure point to `p + mcnt' after we do this. */ |
7035 |
|
|
7036 |
DEBUG_PRINT1 (":\n"); |
DEBUG_PRINT1 (":\n"); |
7037 |
PUSH_FAILURE_POINT (p + mcnt, d, -2); |
PUSH_FAILURE_POINT (p + mcnt, d, -2); |
7038 |
break; |
NEXT; |
7039 |
|
|
7040 |
|
|
7041 |
/* A smart repeat ends with `maybe_pop_jump'. |
/* A smart repeat ends with `maybe_pop_jump'. |
7042 |
We change it to either `pop_failure_jump' or `jump'. */ |
We change it to either `pop_failure_jump' or `jump'. */ |
7043 |
case maybe_pop_jump: |
CASE (maybe_pop_jump): |
7044 |
EXTRACT_NUMBER_AND_INCR (mcnt, p); |
EXTRACT_NUMBER_AND_INCR (mcnt, p); |
7045 |
DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt); |
DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt); |
7046 |
{ |
{ |
7047 |
register unsigned char *p2 = p; |
register UCHAR_T *p2 = p; |
7048 |
|
|
7049 |
/* Compare the beginning of the repeat with what in the |
/* Compare the beginning of the repeat with what in the |
7050 |
pattern follows its end. If we can establish that there |
pattern follows its end. If we can establish that there |
7052 |
would have to backtrack because of (as in, e.g., `a*a') |
would have to backtrack because of (as in, e.g., `a*a') |
7053 |
then we can change to pop_failure_jump, because we'll |
then we can change to pop_failure_jump, because we'll |
7054 |
never have to backtrack. |
never have to backtrack. |
7055 |
|
|
7056 |
This is not true in the case of alternatives: in |
This is not true in the case of alternatives: in |
7057 |
`(a|ab)*' we do need to backtrack to the `ab' alternative |
`(a|ab)*' we do need to backtrack to the `ab' alternative |
7058 |
(e.g., if the string was `ab'). But instead of trying to |
(e.g., if the string was `ab'). But instead of trying to |
7069 |
&& ((re_opcode_t) *p2 == stop_memory |
&& ((re_opcode_t) *p2 == stop_memory |
7070 |
|| (re_opcode_t) *p2 == start_memory)) |
|| (re_opcode_t) *p2 == start_memory)) |
7071 |
p2 += 3; |
p2 += 3; |
7072 |
else if (p2 + 6 < pend |
else if (p2 + 2 + 2 * OFFSET_ADDRESS_SIZE < pend |
7073 |
&& (re_opcode_t) *p2 == dummy_failure_jump) |
&& (re_opcode_t) *p2 == dummy_failure_jump) |
7074 |
p2 += 6; |
p2 += 2 + 2 * OFFSET_ADDRESS_SIZE; |
7075 |
else |
else |
7076 |
break; |
break; |
7077 |
} |
} |
7078 |
|
|
7079 |
p1 = p + mcnt; |
p1 = p + mcnt; |
7080 |
/* p1[0] ... p1[2] are the `on_failure_jump' corresponding |
/* p1[0] ... p1[2] are the `on_failure_jump' corresponding |
7081 |
to the `maybe_finalize_jump' of this case. Examine what |
to the `maybe_finalize_jump' of this case. Examine what |
7082 |
follows. */ |
follows. */ |
7083 |
|
|
7084 |
/* If we're at the end of the pattern, we can change. */ |
/* If we're at the end of the pattern, we can change. */ |
7087 |
/* Consider what happens when matching ":\(.*\)" |
/* Consider what happens when matching ":\(.*\)" |
7088 |
against ":/". I don't really understand this code |
against ":/". I don't really understand this code |
7089 |
yet. */ |
yet. */ |
7090 |
p[-3] = (unsigned char) pop_failure_jump; |
p[-(1+OFFSET_ADDRESS_SIZE)] = (UCHAR_T) |
7091 |
|
pop_failure_jump; |
7092 |
DEBUG_PRINT1 |
DEBUG_PRINT1 |
7093 |
(" End of pattern: change to `pop_failure_jump'.\n"); |
(" End of pattern: change to `pop_failure_jump'.\n"); |
7094 |
} |
} |
7095 |
|
|
7096 |
else if ((re_opcode_t) *p2 == exactn |
else if ((re_opcode_t) *p2 == exactn |
7097 |
|
#ifdef MBS_SUPPORT |
7098 |
|
|| (re_opcode_t) *p2 == exactn_bin |
7099 |
|
#endif |
7100 |
|| (bufp->newline_anchor && (re_opcode_t) *p2 == endline)) |
|| (bufp->newline_anchor && (re_opcode_t) *p2 == endline)) |
7101 |
{ |
{ |
7102 |
register unsigned char c |
register UCHAR_T c |
7103 |
= *p2 == (unsigned char) endline ? '\n' : p2[2]; |
= *p2 == (UCHAR_T) endline ? '\n' : p2[2]; |
7104 |
|
|
7105 |
if ((re_opcode_t) p1[3] == exactn && p1[5] != c) |
if (((re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == exactn |
7106 |
|
#ifdef MBS_SUPPORT |
7107 |
|
|| (re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == exactn_bin |
7108 |
|
#endif |
7109 |
|
) && p1[3+OFFSET_ADDRESS_SIZE] != c) |
7110 |
{ |
{ |
7111 |
p[-3] = (unsigned char) pop_failure_jump; |
p[-(1+OFFSET_ADDRESS_SIZE)] = (UCHAR_T) |
7112 |
DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n", |
pop_failure_jump; |
7113 |
c, p1[5]); |
#ifdef WCHAR |
7114 |
|
DEBUG_PRINT3 (" %C != %C => pop_failure_jump.\n", |
7115 |
|
(wint_t) c, |
7116 |
|
(wint_t) p1[3+OFFSET_ADDRESS_SIZE]); |
7117 |
|
#else |
7118 |
|
DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n", |
7119 |
|
(char) c, |
7120 |
|
(char) p1[3+OFFSET_ADDRESS_SIZE]); |
7121 |
|
#endif |
7122 |
} |
} |
7123 |
|
|
7124 |
|
#ifndef WCHAR |
7125 |
else if ((re_opcode_t) p1[3] == charset |
else if ((re_opcode_t) p1[3] == charset |
7126 |
|| (re_opcode_t) p1[3] == charset_not) |
|| (re_opcode_t) p1[3] == charset_not) |
7127 |
{ |
{ |
7128 |
int not = (re_opcode_t) p1[3] == charset_not; |
int not = (re_opcode_t) p1[3] == charset_not; |
7129 |
|
|
7130 |
if (c < (unsigned char) (p1[4] * BYTEWIDTH) |
if (c < (unsigned) (p1[4] * BYTEWIDTH) |
7131 |
&& p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) |
&& p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) |
7132 |
not = !not; |
not = !not; |
7133 |
|
|
7139 |
DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); |
DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); |
7140 |
} |
} |
7141 |
} |
} |
7142 |
|
#endif /* not WCHAR */ |
7143 |
} |
} |
7144 |
|
#ifndef WCHAR |
7145 |
else if ((re_opcode_t) *p2 == charset) |
else if ((re_opcode_t) *p2 == charset) |
7146 |
{ |
{ |
7147 |
#ifdef DEBUG |
/* We win if the first character of the loop is not part |
7148 |
register unsigned char c |
of the charset. */ |
|
= *p2 == (unsigned char) endline ? '\n' : p2[2]; |
|
|
#endif |
|
|
|
|
7149 |
if ((re_opcode_t) p1[3] == exactn |
if ((re_opcode_t) p1[3] == exactn |
7150 |
&& ! ((int) p2[1] * BYTEWIDTH > (int) p1[4] |
&& ! ((int) p2[1] * BYTEWIDTH > (int) p1[5] |
7151 |
&& (p2[1 + p1[4] / BYTEWIDTH] |
&& (p2[2 + p1[5] / BYTEWIDTH] |
7152 |
& (1 << (p1[4] % BYTEWIDTH))))) |
& (1 << (p1[5] % BYTEWIDTH))))) |
7153 |
{ |
{ |
7154 |
p[-3] = (unsigned char) pop_failure_jump; |
p[-3] = (unsigned char) pop_failure_jump; |
7155 |
DEBUG_PRINT3 (" %c != %c => pop_failure_jump.\n", |
DEBUG_PRINT1 (" No match => pop_failure_jump.\n"); |
|
c, p1[5]); |
|
7156 |
} |
} |
7157 |
|
|
7158 |
else if ((re_opcode_t) p1[3] == charset_not) |
else if ((re_opcode_t) p1[3] == charset_not) |
7159 |
{ |
{ |
7160 |
int idx; |
int idx; |
7190 |
} |
} |
7191 |
} |
} |
7192 |
} |
} |
7193 |
|
#endif /* not WCHAR */ |
7194 |
} |
} |
7195 |
p -= 2; /* Point at relative address again. */ |
p -= OFFSET_ADDRESS_SIZE; /* Point at relative address again. */ |
7196 |
if ((re_opcode_t) p[-1] != pop_failure_jump) |
if ((re_opcode_t) p[-1] != pop_failure_jump) |
7197 |
{ |
{ |
7198 |
p[-1] = (unsigned char) jump; |
p[-1] = (UCHAR_T) jump; |
7199 |
DEBUG_PRINT1 (" Match => jump.\n"); |
DEBUG_PRINT1 (" Match => jump.\n"); |
7200 |
goto unconditional_jump; |
goto unconditional_jump; |
7201 |
} |
} |
7208 |
points put on by this pop_failure_jump's matching |
points put on by this pop_failure_jump's matching |
7209 |
on_failure_jump; we got through the pattern to here from the |
on_failure_jump; we got through the pattern to here from the |
7210 |
matching on_failure_jump, so didn't fail. */ |
matching on_failure_jump, so didn't fail. */ |
7211 |
case pop_failure_jump: |
CASE (pop_failure_jump): |
7212 |
{ |
{ |
7213 |
/* We need to pass separate storage for the lowest and |
/* We need to pass separate storage for the lowest and |
7214 |
highest registers, even though we don't care about the |
highest registers, even though we don't care about the |
7215 |
actual values. Otherwise, we will restore only one |
actual values. Otherwise, we will restore only one |
7216 |
register from the stack, since lowest will == highest in |
register from the stack, since lowest will == highest in |
7217 |
`pop_failure_point'. */ |
`pop_failure_point'. */ |
7218 |
unsigned dummy_low_reg, dummy_high_reg; |
active_reg_t dummy_low_reg, dummy_high_reg; |
7219 |
unsigned char *pdummy; |
UCHAR_T *pdummy = NULL; |
7220 |
const char *sdummy; |
const CHAR_T *sdummy = NULL; |
7221 |
|
|
7222 |
DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n"); |
DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n"); |
7223 |
POP_FAILURE_POINT (sdummy, pdummy, |
POP_FAILURE_POINT (sdummy, pdummy, |
7224 |
dummy_low_reg, dummy_high_reg, |
dummy_low_reg, dummy_high_reg, |
7225 |
reg_dummy, reg_dummy, reg_info_dummy); |
reg_dummy, reg_dummy, reg_info_dummy); |
7226 |
} |
} |
7227 |
|
/* Note fall through. */ |
7228 |
|
|
7229 |
|
unconditional_jump: |
7230 |
|
#ifdef _LIBC |
7231 |
|
DEBUG_PRINT2 ("\n%p: ", p); |
7232 |
|
#else |
7233 |
|
DEBUG_PRINT2 ("\n0x%x: ", p); |
7234 |
|
#endif |
7235 |
/* Note fall through. */ |
/* Note fall through. */ |
7236 |
|
|
|
|
|
7237 |
/* Unconditionally jump (without popping any failure points). */ |
/* Unconditionally jump (without popping any failure points). */ |
7238 |
case jump: |
CASE (jump): |
|
unconditional_jump: |
|
7239 |
EXTRACT_NUMBER_AND_INCR (mcnt, p); /* Get the amount to jump. */ |
EXTRACT_NUMBER_AND_INCR (mcnt, p); /* Get the amount to jump. */ |
7240 |
DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt); |
DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt); |
7241 |
p += mcnt; /* Do the jump. */ |
p += mcnt; /* Do the jump. */ |
7242 |
|
#ifdef _LIBC |
7243 |
|
DEBUG_PRINT2 ("(to %p).\n", p); |
7244 |
|
#else |
7245 |
DEBUG_PRINT2 ("(to 0x%x).\n", p); |
DEBUG_PRINT2 ("(to 0x%x).\n", p); |
7246 |
break; |
#endif |
7247 |
|
NEXT; |
7248 |
|
|
7249 |
|
|
|
|
|
7250 |
/* We need this opcode so we can detect where alternatives end |
/* We need this opcode so we can detect where alternatives end |
7251 |
in `group_match_null_string_p' et al. */ |
in `group_match_null_string_p' et al. */ |
7252 |
case jump_past_alt: |
CASE (jump_past_alt): |
7253 |
DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n"); |
DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n"); |
7254 |
goto unconditional_jump; |
goto unconditional_jump; |
7255 |
|
|
7259 |
pop_failure_jump, also, and with a pattern of, say, `a+', we |
pop_failure_jump, also, and with a pattern of, say, `a+', we |
7260 |
are skipping over the on_failure_jump, so we have to push |
are skipping over the on_failure_jump, so we have to push |
7261 |
something meaningless for pop_failure_jump to pop. */ |
something meaningless for pop_failure_jump to pop. */ |
7262 |
case dummy_failure_jump: |
CASE (dummy_failure_jump): |
7263 |
DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n"); |
DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n"); |
7264 |
/* It doesn't matter what we push for the string here. What |
/* It doesn't matter what we push for the string here. What |
7265 |
the code at `fail' tests is the value for the pattern. */ |
the code at `fail' tests is the value for the pattern. */ |
7266 |
PUSH_FAILURE_POINT (0, 0, -2); |
PUSH_FAILURE_POINT (NULL, NULL, -2); |
7267 |
goto unconditional_jump; |
goto unconditional_jump; |
7268 |
|
|
7269 |
|
|
7272 |
we don't want the failure point for the alternative to be |
we don't want the failure point for the alternative to be |
7273 |
popped. For example, matching `(a|ab)*' against `aab' |
popped. For example, matching `(a|ab)*' against `aab' |
7274 |
requires that we match the `ab' alternative. */ |
requires that we match the `ab' alternative. */ |
7275 |
case push_dummy_failure: |
CASE (push_dummy_failure): |
7276 |
DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n"); |
DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n"); |
7277 |
/* See comments just above at `dummy_failure_jump' about the |
/* See comments just above at `dummy_failure_jump' about the |
7278 |
two zeroes. */ |
two zeroes. */ |
7279 |
PUSH_FAILURE_POINT (0, 0, -2); |
PUSH_FAILURE_POINT (NULL, NULL, -2); |
7280 |
break; |
NEXT; |
7281 |
|
|
7282 |
/* Have to succeed matching what follows at least n times. |
/* Have to succeed matching what follows at least n times. |
7283 |
After that, handle like `on_failure_jump'. */ |
After that, handle like `on_failure_jump'. */ |
7284 |
case succeed_n: |
CASE (succeed_n): |
7285 |
EXTRACT_NUMBER (mcnt, p + 2); |
EXTRACT_NUMBER (mcnt, p + OFFSET_ADDRESS_SIZE); |
7286 |
DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt); |
DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt); |
7287 |
|
|
7288 |
assert (mcnt >= 0); |
assert (mcnt >= 0); |
7290 |
if (mcnt > 0) |
if (mcnt > 0) |
7291 |
{ |
{ |
7292 |
mcnt--; |
mcnt--; |
7293 |
p += 2; |
p += OFFSET_ADDRESS_SIZE; |
7294 |
STORE_NUMBER_AND_INCR (p, mcnt); |
STORE_NUMBER_AND_INCR (p, mcnt); |
7295 |
DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p, mcnt); |
#ifdef _LIBC |
7296 |
|
DEBUG_PRINT3 (" Setting %p to %d.\n", p - OFFSET_ADDRESS_SIZE |
7297 |
|
, mcnt); |
7298 |
|
#else |
7299 |
|
DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p - OFFSET_ADDRESS_SIZE |
7300 |
|
, mcnt); |
7301 |
|
#endif |
7302 |
} |
} |
7303 |
else if (mcnt == 0) |
else if (mcnt == 0) |
7304 |
{ |
{ |
7305 |
DEBUG_PRINT2 (" Setting two bytes from 0x%x to no_op.\n", p+2); |
#ifdef _LIBC |
7306 |
p[2] = (unsigned char) no_op; |
DEBUG_PRINT2 (" Setting two bytes from %p to no_op.\n", |
7307 |
p[3] = (unsigned char) no_op; |
p + OFFSET_ADDRESS_SIZE); |
7308 |
|
#else |
7309 |
|
DEBUG_PRINT2 (" Setting two bytes from 0x%x to no_op.\n", |
7310 |
|
p + OFFSET_ADDRESS_SIZE); |
7311 |
|
#endif /* _LIBC */ |
7312 |
|
|
7313 |
|
#ifdef WCHAR |
7314 |
|
p[1] = (UCHAR_T) no_op; |
7315 |
|
#else |
7316 |
|
p[2] = (UCHAR_T) no_op; |
7317 |
|
p[3] = (UCHAR_T) no_op; |
7318 |
|
#endif /* WCHAR */ |
7319 |
goto on_failure; |
goto on_failure; |
7320 |
} |
} |
7321 |
break; |
NEXT; |
7322 |
|
|
7323 |
case jump_n: |
CASE (jump_n): |
7324 |
EXTRACT_NUMBER (mcnt, p + 2); |
EXTRACT_NUMBER (mcnt, p + OFFSET_ADDRESS_SIZE); |
7325 |
DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt); |
DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt); |
7326 |
|
|
7327 |
/* Originally, this is how many times we CAN jump. */ |
/* Originally, this is how many times we CAN jump. */ |
7328 |
if (mcnt) |
if (mcnt) |
7329 |
{ |
{ |
7330 |
mcnt--; |
mcnt--; |
7331 |
STORE_NUMBER (p + 2, mcnt); |
STORE_NUMBER (p + OFFSET_ADDRESS_SIZE, mcnt); |
7332 |
goto unconditional_jump; |
|
7333 |
|
#ifdef _LIBC |
7334 |
|
DEBUG_PRINT3 (" Setting %p to %d.\n", p + OFFSET_ADDRESS_SIZE, |
7335 |
|
mcnt); |
7336 |
|
#else |
7337 |
|
DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p + OFFSET_ADDRESS_SIZE, |
7338 |
|
mcnt); |
7339 |
|
#endif /* _LIBC */ |
7340 |
|
goto unconditional_jump; |
7341 |
} |
} |
7342 |
/* If don't have to jump any more, skip over the rest of command. */ |
/* If don't have to jump any more, skip over the rest of command. */ |
7343 |
else |
else |
7344 |
p += 4; |
p += 2 * OFFSET_ADDRESS_SIZE; |
7345 |
break; |
NEXT; |
7346 |
|
|
7347 |
case set_number_at: |
CASE (set_number_at): |
7348 |
{ |
{ |
7349 |
DEBUG_PRINT1 ("EXECUTING set_number_at.\n"); |
DEBUG_PRINT1 ("EXECUTING set_number_at.\n"); |
7350 |
|
|
7351 |
EXTRACT_NUMBER_AND_INCR (mcnt, p); |
EXTRACT_NUMBER_AND_INCR (mcnt, p); |
7352 |
p1 = p + mcnt; |
p1 = p + mcnt; |
7353 |
EXTRACT_NUMBER_AND_INCR (mcnt, p); |
EXTRACT_NUMBER_AND_INCR (mcnt, p); |
7354 |
|
#ifdef _LIBC |
7355 |
|
DEBUG_PRINT3 (" Setting %p to %d.\n", p1, mcnt); |
7356 |
|
#else |
7357 |
DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p1, mcnt); |
DEBUG_PRINT3 (" Setting 0x%x to %d.\n", p1, mcnt); |
7358 |
|
#endif |
7359 |
STORE_NUMBER (p1, mcnt); |
STORE_NUMBER (p1, mcnt); |
7360 |
break; |
NEXT; |
7361 |
} |
} |
7362 |
|
|
7363 |
case wordbound: |
#if 0 |
7364 |
DEBUG_PRINT1 ("EXECUTING wordbound.\n"); |
/* The DEC Alpha C compiler 3.x generates incorrect code for the |
7365 |
if (AT_WORD_BOUNDARY (d)) |
test WORDCHAR_P (d - 1) != WORDCHAR_P (d) in the expansion of |
7366 |
break; |
AT_WORD_BOUNDARY, so this code is disabled. Expanding the |
7367 |
goto fail; |
macro and introducing temporary variables works around the bug. */ |
7368 |
|
|
7369 |
case notwordbound: |
CASE (wordbound): |
7370 |
DEBUG_PRINT1 ("EXECUTING notwordbound.\n"); |
DEBUG_PRINT1 ("EXECUTING wordbound.\n"); |
7371 |
|
if (AT_WORD_BOUNDARY (d)) |
7372 |
|
{ |
7373 |
|
NEXT; |
7374 |
|
} |
7375 |
|
goto fail; |
7376 |
|
|
7377 |
|
CASE (notwordbound): |
7378 |
|
DEBUG_PRINT1 ("EXECUTING notwordbound.\n"); |
7379 |
if (AT_WORD_BOUNDARY (d)) |
if (AT_WORD_BOUNDARY (d)) |
7380 |
goto fail; |
goto fail; |
7381 |
break; |
NEXT; |
7382 |
|
#else |
7383 |
|
CASE (wordbound): |
7384 |
|
{ |
7385 |
|
boolean prevchar, thischar; |
7386 |
|
|
7387 |
case wordbeg: |
DEBUG_PRINT1 ("EXECUTING wordbound.\n"); |
7388 |
|
if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d)) |
7389 |
|
{ |
7390 |
|
NEXT; |
7391 |
|
} |
7392 |
|
|
7393 |
|
prevchar = WORDCHAR_P (d - 1); |
7394 |
|
thischar = WORDCHAR_P (d); |
7395 |
|
if (prevchar != thischar) |
7396 |
|
{ |
7397 |
|
NEXT; |
7398 |
|
} |
7399 |
|
goto fail; |
7400 |
|
} |
7401 |
|
|
7402 |
|
CASE (notwordbound): |
7403 |
|
{ |
7404 |
|
boolean prevchar, thischar; |
7405 |
|
|
7406 |
|
DEBUG_PRINT1 ("EXECUTING notwordbound.\n"); |
7407 |
|
if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d)) |
7408 |
|
goto fail; |
7409 |
|
|
7410 |
|
prevchar = WORDCHAR_P (d - 1); |
7411 |
|
thischar = WORDCHAR_P (d); |
7412 |
|
if (prevchar != thischar) |
7413 |
|
goto fail; |
7414 |
|
NEXT; |
7415 |
|
} |
7416 |
|
#endif |
7417 |
|
|
7418 |
|
CASE (wordbeg): |
7419 |
DEBUG_PRINT1 ("EXECUTING wordbeg.\n"); |
DEBUG_PRINT1 ("EXECUTING wordbeg.\n"); |
7420 |
if (WORDCHAR_P (d) && (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1))) |
if (!AT_STRINGS_END (d) && WORDCHAR_P (d) |
7421 |
break; |
&& (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1))) |
7422 |
|
{ |
7423 |
|
NEXT; |
7424 |
|
} |
7425 |
goto fail; |
goto fail; |
7426 |
|
|
7427 |
case wordend: |
CASE (wordend): |
7428 |
DEBUG_PRINT1 ("EXECUTING wordend.\n"); |
DEBUG_PRINT1 ("EXECUTING wordend.\n"); |
7429 |
if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1) |
if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1) |
7430 |
&& (!WORDCHAR_P (d) || AT_STRINGS_END (d))) |
&& (AT_STRINGS_END (d) || !WORDCHAR_P (d))) |
7431 |
break; |
{ |
7432 |
|
NEXT; |
7433 |
|
} |
7434 |
goto fail; |
goto fail; |
7435 |
|
|
7436 |
#ifdef emacs |
#ifdef emacs |
7437 |
case before_dot: |
CASE (before_dot): |
7438 |
DEBUG_PRINT1 ("EXECUTING before_dot.\n"); |
DEBUG_PRINT1 ("EXECUTING before_dot.\n"); |
7439 |
if (PTR_CHAR_POS ((unsigned char *) d) >= point) |
if (PTR_CHAR_POS ((unsigned char *) d) >= point) |
7440 |
goto fail; |
goto fail; |
7441 |
break; |
NEXT; |
7442 |
|
|
7443 |
case at_dot: |
CASE (at_dot): |
7444 |
DEBUG_PRINT1 ("EXECUTING at_dot.\n"); |
DEBUG_PRINT1 ("EXECUTING at_dot.\n"); |
7445 |
if (PTR_CHAR_POS ((unsigned char *) d) != point) |
if (PTR_CHAR_POS ((unsigned char *) d) != point) |
7446 |
goto fail; |
goto fail; |
7447 |
break; |
NEXT; |
7448 |
|
|
7449 |
case after_dot: |
CASE (after_dot): |
7450 |
DEBUG_PRINT1 ("EXECUTING after_dot.\n"); |
DEBUG_PRINT1 ("EXECUTING after_dot.\n"); |
7451 |
if (PTR_CHAR_POS ((unsigned char *) d) <= point) |
if (PTR_CHAR_POS ((unsigned char *) d) <= point) |
7452 |
goto fail; |
goto fail; |
7453 |
break; |
NEXT; |
|
#if 0 /* not emacs19 */ |
|
|
case at_dot: |
|
|
DEBUG_PRINT1 ("EXECUTING at_dot.\n"); |
|
|
if (PTR_CHAR_POS ((unsigned char *) d) + 1 != point) |
|
|
goto fail; |
|
|
break; |
|
|
#endif /* not emacs19 */ |
|
7454 |
|
|
7455 |
case syntaxspec: |
CASE (syntaxspec): |
7456 |
DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt); |
DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt); |
7457 |
mcnt = *p++; |
mcnt = *p++; |
7458 |
goto matchsyntax; |
goto matchsyntax; |
7459 |
|
|
7460 |
case wordchar: |
CASE (wordchar): |
7461 |
DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n"); |
DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n"); |
7462 |
mcnt = (int) Sword; |
mcnt = (int) Sword; |
7463 |
matchsyntax: |
matchsyntax: |
7467 |
if (SYNTAX (d[-1]) != (enum syntaxcode) mcnt) |
if (SYNTAX (d[-1]) != (enum syntaxcode) mcnt) |
7468 |
goto fail; |
goto fail; |
7469 |
SET_REGS_MATCHED (); |
SET_REGS_MATCHED (); |
7470 |
break; |
NEXT; |
7471 |
|
|
7472 |
case notsyntaxspec: |
CASE (notsyntaxspec): |
7473 |
DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt); |
DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt); |
7474 |
mcnt = *p++; |
mcnt = *p++; |
7475 |
goto matchnotsyntax; |
goto matchnotsyntax; |
7476 |
|
|
7477 |
case notwordchar: |
CASE (notwordchar): |
7478 |
DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n"); |
DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n"); |
7479 |
mcnt = (int) Sword; |
mcnt = (int) Sword; |
7480 |
matchnotsyntax: |
matchnotsyntax: |
7484 |
if (SYNTAX (d[-1]) == (enum syntaxcode) mcnt) |
if (SYNTAX (d[-1]) == (enum syntaxcode) mcnt) |
7485 |
goto fail; |
goto fail; |
7486 |
SET_REGS_MATCHED (); |
SET_REGS_MATCHED (); |
7487 |
break; |
NEXT; |
7488 |
|
|
7489 |
#else /* not emacs */ |
#else /* not emacs */ |
7490 |
case wordchar: |
CASE (wordchar): |
7491 |
DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n"); |
DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n"); |
7492 |
PREFETCH (); |
PREFETCH (); |
7493 |
if (!WORDCHAR_P (d)) |
if (!WORDCHAR_P (d)) |
7494 |
goto fail; |
goto fail; |
7495 |
SET_REGS_MATCHED (); |
SET_REGS_MATCHED (); |
7496 |
d++; |
d++; |
7497 |
break; |
NEXT; |
7498 |
|
|
7499 |
case notwordchar: |
CASE (notwordchar): |
7500 |
DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n"); |
DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n"); |
7501 |
PREFETCH (); |
PREFETCH (); |
7502 |
if (WORDCHAR_P (d)) |
if (WORDCHAR_P (d)) |
7503 |
goto fail; |
goto fail; |
7504 |
SET_REGS_MATCHED (); |
SET_REGS_MATCHED (); |
7505 |
d++; |
d++; |
7506 |
break; |
NEXT; |
7507 |
#endif /* not emacs */ |
#endif /* not emacs */ |
7508 |
|
|
7509 |
|
#ifndef __GNUC__ |
7510 |
default: |
default: |
7511 |
abort (); |
abort (); |
7512 |
} |
} |
7513 |
continue; /* Successfully executed one pattern command; keep going. */ |
continue; /* Successfully executed one pattern command; keep going. */ |
7514 |
|
#endif |
7515 |
|
|
7516 |
|
|
7517 |
/* We goto here if a matching operation fails. */ |
/* We goto here if a matching operation fails. */ |
7532 |
if (p < pend) |
if (p < pend) |
7533 |
{ |
{ |
7534 |
boolean is_a_jump_n = false; |
boolean is_a_jump_n = false; |
7535 |
|
|
7536 |
/* If failed to a backwards jump that's part of a repetition |
/* If failed to a backwards jump that's part of a repetition |
7537 |
loop, need to pop this failure point and use the next one. */ |
loop, need to pop this failure point and use the next one. */ |
7538 |
switch ((re_opcode_t) *p) |
switch ((re_opcode_t) *p) |
7544 |
case jump: |
case jump: |
7545 |
p1 = p + 1; |
p1 = p + 1; |
7546 |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
7547 |
p1 += mcnt; |
p1 += mcnt; |
7548 |
|
|
7549 |
if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n) |
if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n) |
7550 |
|| (!is_a_jump_n |
|| (!is_a_jump_n |
7575 |
|
|
7576 |
|
|
7577 |
/* We are passed P pointing to a register number after a start_memory. |
/* We are passed P pointing to a register number after a start_memory. |
7578 |
|
|
7579 |
Return true if the pattern up to the corresponding stop_memory can |
Return true if the pattern up to the corresponding stop_memory can |
7580 |
match the empty string, and false otherwise. |
match the empty string, and false otherwise. |
7581 |
|
|
7582 |
If we find the matching stop_memory, sets P to point to one past its number. |
If we find the matching stop_memory, sets P to point to one past its number. |
7583 |
Otherwise, sets P to an undefined byte less than or equal to END. |
Otherwise, sets P to an undefined byte less than or equal to END. |
7584 |
|
|
7585 |
We don't handle duplicates properly (yet). */ |
We don't handle duplicates properly (yet). */ |
7586 |
|
|
7587 |
static boolean |
static boolean |
7588 |
group_match_null_string_p (p, end, reg_info) |
PREFIX(group_match_null_string_p) (UCHAR_T **p, UCHAR_T *end, |
7589 |
unsigned char **p, *end; |
PREFIX(register_info_type) *reg_info) |
|
register_info_type *reg_info; |
|
7590 |
{ |
{ |
7591 |
int mcnt; |
int mcnt; |
7592 |
/* Point to after the args to the start_memory. */ |
/* Point to after the args to the start_memory. */ |
7593 |
unsigned char *p1 = *p + 2; |
UCHAR_T *p1 = *p + 2; |
7594 |
|
|
7595 |
while (p1 < end) |
while (p1 < end) |
7596 |
{ |
{ |
7597 |
/* Skip over opcodes that can match nothing, and return true or |
/* Skip over opcodes that can match nothing, and return true or |
7598 |
false, as appropriate, when we get to one that can't, or to the |
false, as appropriate, when we get to one that can't, or to the |
7599 |
matching stop_memory. */ |
matching stop_memory. */ |
7600 |
|
|
7601 |
switch ((re_opcode_t) *p1) |
switch ((re_opcode_t) *p1) |
7602 |
{ |
{ |
7603 |
/* Could be either a loop or a series of alternatives. */ |
/* Could be either a loop or a series of alternatives. */ |
7604 |
case on_failure_jump: |
case on_failure_jump: |
7605 |
p1++; |
p1++; |
7606 |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
7607 |
|
|
7608 |
/* If the next operation is not a jump backwards in the |
/* If the next operation is not a jump backwards in the |
7609 |
pattern. */ |
pattern. */ |
7610 |
|
|
7618 |
|
|
7619 |
/on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6 |
/on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6 |
7620 |
/on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3 |
/on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3 |
7621 |
/exactn/1/c |
/exactn/1/c |
7622 |
|
|
7623 |
So, we have to first go through the first (n-1) |
So, we have to first go through the first (n-1) |
7624 |
alternatives and then deal with the last one separately. */ |
alternatives and then deal with the last one separately. */ |
7628 |
with an on_failure_jump (see above) that jumps to right |
with an on_failure_jump (see above) that jumps to right |
7629 |
past a jump_past_alt. */ |
past a jump_past_alt. */ |
7630 |
|
|
7631 |
while ((re_opcode_t) p1[mcnt-3] == jump_past_alt) |
while ((re_opcode_t) p1[mcnt-(1+OFFSET_ADDRESS_SIZE)] == |
7632 |
|
jump_past_alt) |
7633 |
{ |
{ |
7634 |
/* `mcnt' holds how many bytes long the alternative |
/* `mcnt' holds how many bytes long the alternative |
7635 |
is, including the ending `jump_past_alt' and |
is, including the ending `jump_past_alt' and |
7636 |
its number. */ |
its number. */ |
7637 |
|
|
7638 |
if (!alt_match_null_string_p (p1, p1 + mcnt - 3, |
if (!PREFIX(alt_match_null_string_p) (p1, p1 + mcnt - |
7639 |
reg_info)) |
(1 + OFFSET_ADDRESS_SIZE), |
7640 |
|
reg_info)) |
7641 |
return false; |
return false; |
7642 |
|
|
7643 |
/* Move to right after this alternative, including the |
/* Move to right after this alternative, including the |
7644 |
jump_past_alt. */ |
jump_past_alt. */ |
7645 |
p1 += mcnt; |
p1 += mcnt; |
7646 |
|
|
7647 |
/* Break if it's the beginning of an n-th alternative |
/* Break if it's the beginning of an n-th alternative |
7648 |
that doesn't begin with an on_failure_jump. */ |
that doesn't begin with an on_failure_jump. */ |
7649 |
if ((re_opcode_t) *p1 != on_failure_jump) |
if ((re_opcode_t) *p1 != on_failure_jump) |
7650 |
break; |
break; |
7651 |
|
|
7652 |
/* Still have to check that it's not an n-th |
/* Still have to check that it's not an n-th |
7653 |
alternative that starts with an on_failure_jump. */ |
alternative that starts with an on_failure_jump. */ |
7654 |
p1++; |
p1++; |
7655 |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
7656 |
if ((re_opcode_t) p1[mcnt-3] != jump_past_alt) |
if ((re_opcode_t) p1[mcnt-(1+OFFSET_ADDRESS_SIZE)] != |
7657 |
|
jump_past_alt) |
7658 |
{ |
{ |
7659 |
/* Get to the beginning of the n-th alternative. */ |
/* Get to the beginning of the n-th alternative. */ |
7660 |
p1 -= 3; |
p1 -= 1 + OFFSET_ADDRESS_SIZE; |
7661 |
break; |
break; |
7662 |
} |
} |
7663 |
} |
} |
7665 |
/* Deal with the last alternative: go back and get number |
/* Deal with the last alternative: go back and get number |
7666 |
of the `jump_past_alt' just before it. `mcnt' contains |
of the `jump_past_alt' just before it. `mcnt' contains |
7667 |
the length of the alternative. */ |
the length of the alternative. */ |
7668 |
EXTRACT_NUMBER (mcnt, p1 - 2); |
EXTRACT_NUMBER (mcnt, p1 - OFFSET_ADDRESS_SIZE); |
7669 |
|
|
7670 |
if (!alt_match_null_string_p (p1, p1 + mcnt, reg_info)) |
if (!PREFIX(alt_match_null_string_p) (p1, p1 + mcnt, reg_info)) |
7671 |
return false; |
return false; |
7672 |
|
|
7673 |
p1 += mcnt; /* Get past the n-th alternative. */ |
p1 += mcnt; /* Get past the n-th alternative. */ |
7674 |
} /* if mcnt > 0 */ |
} /* if mcnt > 0 */ |
7675 |
break; |
break; |
7676 |
|
|
7677 |
|
|
7678 |
case stop_memory: |
case stop_memory: |
7679 |
assert (p1[1] == **p); |
assert (p1[1] == **p); |
7680 |
*p = p1 + 2; |
*p = p1 + 2; |
7681 |
return true; |
return true; |
7682 |
|
|
7683 |
|
|
7684 |
default: |
default: |
7685 |
if (!common_op_match_null_string_p (&p1, end, reg_info)) |
if (!PREFIX(common_op_match_null_string_p) (&p1, end, reg_info)) |
7686 |
return false; |
return false; |
7687 |
} |
} |
7688 |
} /* while p1 < end */ |
} /* while p1 < end */ |
7694 |
/* Similar to group_match_null_string_p, but doesn't deal with alternatives: |
/* Similar to group_match_null_string_p, but doesn't deal with alternatives: |
7695 |
It expects P to be the first byte of a single alternative and END one |
It expects P to be the first byte of a single alternative and END one |
7696 |
byte past the last. The alternative can contain groups. */ |
byte past the last. The alternative can contain groups. */ |
7697 |
|
|
7698 |
static boolean |
static boolean |
7699 |
alt_match_null_string_p (p, end, reg_info) |
PREFIX(alt_match_null_string_p) (UCHAR_T *p, UCHAR_T *end, |
7700 |
unsigned char *p, *end; |
PREFIX(register_info_type) *reg_info) |
|
register_info_type *reg_info; |
|
7701 |
{ |
{ |
7702 |
int mcnt; |
int mcnt; |
7703 |
unsigned char *p1 = p; |
UCHAR_T *p1 = p; |
7704 |
|
|
7705 |
while (p1 < end) |
while (p1 < end) |
7706 |
{ |
{ |
7707 |
/* Skip over opcodes that can match nothing, and break when we get |
/* Skip over opcodes that can match nothing, and break when we get |
7708 |
to one that can't. */ |
to one that can't. */ |
7709 |
|
|
7710 |
switch ((re_opcode_t) *p1) |
switch ((re_opcode_t) *p1) |
7711 |
{ |
{ |
7712 |
/* It's a loop. */ |
/* It's a loop. */ |
7715 |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
7716 |
p1 += mcnt; |
p1 += mcnt; |
7717 |
break; |
break; |
7718 |
|
|
7719 |
default: |
default: |
7720 |
if (!common_op_match_null_string_p (&p1, end, reg_info)) |
if (!PREFIX(common_op_match_null_string_p) (&p1, end, reg_info)) |
7721 |
return false; |
return false; |
7722 |
} |
} |
7723 |
} /* while p1 < end */ |
} /* while p1 < end */ |
7727 |
|
|
7728 |
|
|
7729 |
/* Deals with the ops common to group_match_null_string_p and |
/* Deals with the ops common to group_match_null_string_p and |
7730 |
alt_match_null_string_p. |
alt_match_null_string_p. |
7731 |
|
|
7732 |
Sets P to one after the op and its arguments, if any. */ |
Sets P to one after the op and its arguments, if any. */ |
7733 |
|
|
7734 |
static boolean |
static boolean |
7735 |
common_op_match_null_string_p (p, end, reg_info) |
PREFIX(common_op_match_null_string_p) (UCHAR_T **p, UCHAR_T *end, |
7736 |
unsigned char **p, *end; |
PREFIX(register_info_type) *reg_info) |
|
register_info_type *reg_info; |
|
7737 |
{ |
{ |
7738 |
int mcnt; |
int mcnt; |
7739 |
boolean ret; |
boolean ret; |
7740 |
int reg_no; |
int reg_no; |
7741 |
unsigned char *p1 = *p; |
UCHAR_T *p1 = *p; |
7742 |
|
|
7743 |
switch ((re_opcode_t) *p1++) |
switch ((re_opcode_t) *p1++) |
7744 |
{ |
{ |
7761 |
case start_memory: |
case start_memory: |
7762 |
reg_no = *p1; |
reg_no = *p1; |
7763 |
assert (reg_no > 0 && reg_no <= MAX_REGNUM); |
assert (reg_no > 0 && reg_no <= MAX_REGNUM); |
7764 |
ret = group_match_null_string_p (&p1, end, reg_info); |
ret = PREFIX(group_match_null_string_p) (&p1, end, reg_info); |
7765 |
|
|
7766 |
/* Have to set this here in case we're checking a group which |
/* Have to set this here in case we're checking a group which |
7767 |
contains a group and a back reference to it. */ |
contains a group and a back reference to it. */ |
7768 |
|
|
7772 |
if (!ret) |
if (!ret) |
7773 |
return false; |
return false; |
7774 |
break; |
break; |
7775 |
|
|
7776 |
/* If this is an optimized succeed_n for zero times, make the jump. */ |
/* If this is an optimized succeed_n for zero times, make the jump. */ |
7777 |
case jump: |
case jump: |
7778 |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
7784 |
|
|
7785 |
case succeed_n: |
case succeed_n: |
7786 |
/* Get to the number of times to succeed. */ |
/* Get to the number of times to succeed. */ |
7787 |
p1 += 2; |
p1 += OFFSET_ADDRESS_SIZE; |
7788 |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
7789 |
|
|
7790 |
if (mcnt == 0) |
if (mcnt == 0) |
7791 |
{ |
{ |
7792 |
p1 -= 4; |
p1 -= 2 * OFFSET_ADDRESS_SIZE; |
7793 |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
EXTRACT_NUMBER_AND_INCR (mcnt, p1); |
7794 |
p1 += mcnt; |
p1 += mcnt; |
7795 |
} |
} |
7797 |
return false; |
return false; |
7798 |
break; |
break; |
7799 |
|
|
7800 |
case duplicate: |
case duplicate: |
7801 |
if (!REG_MATCH_NULL_STRING_P (reg_info[*p1])) |
if (!REG_MATCH_NULL_STRING_P (reg_info[*p1])) |
7802 |
return false; |
return false; |
7803 |
break; |
break; |
7804 |
|
|
7805 |
case set_number_at: |
case set_number_at: |
7806 |
p1 += 4; |
p1 += 2 * OFFSET_ADDRESS_SIZE; |
7807 |
|
|
7808 |
default: |
default: |
7809 |
/* All other opcodes mean we cannot match the empty string. */ |
/* All other opcodes mean we cannot match the empty string. */ |
7817 |
|
|
7818 |
/* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN |
/* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN |
7819 |
bytes; nonzero otherwise. */ |
bytes; nonzero otherwise. */ |
7820 |
|
|
7821 |
static int |
static int |
7822 |
bcmp_translate (s1, s2, len, translate) |
PREFIX(bcmp_translate) (const CHAR_T *s1, const CHAR_T *s2, |
7823 |
unsigned char *s1, *s2; |
register int len, |
7824 |
register int len; |
RE_TRANSLATE_TYPE translate) |
|
char *translate; |
|
7825 |
{ |
{ |
7826 |
register unsigned char *p1 = s1, *p2 = s2; |
register const UCHAR_T *p1 = (const UCHAR_T *) s1; |
7827 |
|
register const UCHAR_T *p2 = (const UCHAR_T *) s2; |
7828 |
while (len) |
while (len) |
7829 |
{ |
{ |
7830 |
|
#ifdef WCHAR |
7831 |
|
if (((*p1<=0xff)?translate[*p1++]:*p1++) |
7832 |
|
!= ((*p2<=0xff)?translate[*p2++]:*p2++)) |
7833 |
|
return 1; |
7834 |
|
#else /* BYTE */ |
7835 |
if (translate[*p1++] != translate[*p2++]) return 1; |
if (translate[*p1++] != translate[*p2++]) return 1; |
7836 |
|
#endif /* WCHAR */ |
7837 |
len--; |
len--; |
7838 |
} |
} |
7839 |
return 0; |
return 0; |
7840 |
} |
} |
7841 |
|
|
7842 |
|
|
7843 |
|
#else /* not INSIDE_RECURSION */ |
7844 |
|
|
7845 |
/* Entry points for GNU code. */ |
/* Entry points for GNU code. */ |
7846 |
|
|
7847 |
/* re_compile_pattern is the GNU regular expression compiler: it |
/* re_compile_pattern is the GNU regular expression compiler: it |
7848 |
compiles PATTERN (of length SIZE) and puts the result in BUFP. |
compiles PATTERN (of length SIZE) and puts the result in BUFP. |
7849 |
Returns 0 if the pattern was valid, otherwise an error string. |
Returns 0 if the pattern was valid, otherwise an error string. |
7850 |
|
|
7851 |
Assumes the `allocated' (and perhaps `buffer') and `translate' fields |
Assumes the `allocated' (and perhaps `buffer') and `translate' fields |
7852 |
are set in BUFP on entry. |
are set in BUFP on entry. |
7853 |
|
|
7854 |
We call regex_compile to do the actual compilation. */ |
We call regex_compile to do the actual compilation. */ |
7855 |
|
|
7856 |
const char * |
const char * |
7857 |
re_compile_pattern (pattern, length, bufp) |
re_compile_pattern (const char *pattern, |
7858 |
const char *pattern; |
size_t length, |
7859 |
int length; |
struct re_pattern_buffer *bufp) |
|
struct re_pattern_buffer *bufp; |
|
7860 |
{ |
{ |
7861 |
reg_errcode_t ret; |
reg_errcode_t ret; |
7862 |
|
|
7863 |
/* GNU code is written to assume at least RE_NREGS registers will be set |
/* GNU code is written to assume at least RE_NREGS registers will be set |
7864 |
(and at least one extra will be -1). */ |
(and at least one extra will be -1). */ |
7865 |
bufp->regs_allocated = REGS_UNALLOCATED; |
bufp->regs_allocated = REGS_UNALLOCATED; |
7866 |
|
|
7867 |
/* And GNU code determines whether or not to get register information |
/* And GNU code determines whether or not to get register information |
7868 |
by passing null for the REGS argument to re_match, etc., not by |
by passing null for the REGS argument to re_match, etc., not by |
7869 |
setting no_sub. */ |
setting no_sub. */ |
7870 |
bufp->no_sub = 0; |
bufp->no_sub = 0; |
7871 |
|
|
7872 |
/* Match anchors at newline. */ |
/* Match anchors at newline. */ |
7873 |
bufp->newline_anchor = 1; |
bufp->newline_anchor = 1; |
|
|
|
|
ret = regex_compile (pattern, length, re_syntax_options, bufp); |
|
7874 |
|
|
7875 |
return re_error_msg[(int) ret]; |
# ifdef MBS_SUPPORT |
7876 |
} |
if (MB_CUR_MAX != 1) |
7877 |
|
ret = wcs_regex_compile (pattern, length, re_syntax_options, bufp); |
7878 |
|
else |
7879 |
|
# endif |
7880 |
|
ret = byte_regex_compile (pattern, length, re_syntax_options, bufp); |
7881 |
|
|
7882 |
|
if (!ret) |
7883 |
|
return NULL; |
7884 |
|
return gettext (re_error_msgid + re_error_msgid_idx[(int) ret]); |
7885 |
|
} |
7886 |
|
#ifdef _LIBC |
7887 |
|
weak_alias (__re_compile_pattern, re_compile_pattern) |
7888 |
|
#endif |
7889 |
|
|
7890 |
/* Entry points compatible with 4.2 BSD regex library. We don't define |
/* Entry points compatible with 4.2 BSD regex library. We don't define |
7891 |
them unless specifically requested. */ |
them unless specifically requested. */ |
7892 |
|
|
7893 |
#ifdef _REGEX_RE_COMP |
#if defined _REGEX_RE_COMP || defined _LIBC |
7894 |
|
|
7895 |
/* BSD has one and only one pattern buffer. */ |
/* BSD has one and only one pattern buffer. */ |
7896 |
static struct re_pattern_buffer re_comp_buf; |
static struct re_pattern_buffer re_comp_buf; |
7897 |
|
|
7898 |
char * |
char * |
7899 |
re_comp (s) |
#ifdef _LIBC |
7900 |
const char *s; |
/* Make these definitions weak in libc, so POSIX programs can redefine |
7901 |
|
these names if they don't use our functions, and still use |
7902 |
|
regcomp/regexec below without link errors. */ |
7903 |
|
weak_function |
7904 |
|
#endif |
7905 |
|
re_comp (const char *s) |
7906 |
{ |
{ |
7907 |
reg_errcode_t ret; |
reg_errcode_t ret; |
7908 |
|
|
7909 |
if (!s) |
if (!s) |
7910 |
{ |
{ |
7911 |
if (!re_comp_buf.buffer) |
if (!re_comp_buf.buffer) |
7912 |
return "No previous regular expression"; |
return (char *) gettext ("No previous regular expression"); |
7913 |
return 0; |
return 0; |
7914 |
} |
} |
7915 |
|
|
7916 |
if (!re_comp_buf.buffer) |
if (!re_comp_buf.buffer) |
7917 |
{ |
{ |
7918 |
re_comp_buf.buffer = (unsigned char *) malloc (200); |
re_comp_buf.buffer = malloc (200); |
7919 |
if (re_comp_buf.buffer == NULL) |
if (re_comp_buf.buffer == NULL) |
7920 |
return "Memory exhausted"; |
return (char *) gettext (re_error_msgid |
7921 |
|
+ re_error_msgid_idx[(int) REG_ESPACE]); |
7922 |
re_comp_buf.allocated = 200; |
re_comp_buf.allocated = 200; |
7923 |
|
|
7924 |
re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH); |
re_comp_buf.fastmap = malloc (1 << BYTEWIDTH); |
7925 |
if (re_comp_buf.fastmap == NULL) |
if (re_comp_buf.fastmap == NULL) |
7926 |
return "Memory exhausted"; |
return (char *) gettext (re_error_msgid |
7927 |
|
+ re_error_msgid_idx[(int) REG_ESPACE]); |
7928 |
} |
} |
7929 |
|
|
7930 |
/* Since `re_exec' always passes NULL for the `regs' argument, we |
/* Since `re_exec' always passes NULL for the `regs' argument, we |
7933 |
/* Match anchors at newlines. */ |
/* Match anchors at newlines. */ |
7934 |
re_comp_buf.newline_anchor = 1; |
re_comp_buf.newline_anchor = 1; |
7935 |
|
|
7936 |
ret = regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf); |
# ifdef MBS_SUPPORT |
7937 |
|
if (MB_CUR_MAX != 1) |
7938 |
/* Yes, we're discarding `const' here. */ |
ret = wcs_regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf); |
7939 |
return (char *) re_error_msg[(int) ret]; |
else |
7940 |
|
# endif |
7941 |
|
ret = byte_regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf); |
7942 |
|
|
7943 |
|
if (!ret) |
7944 |
|
return NULL; |
7945 |
|
|
7946 |
|
/* Yes, we're discarding `const' here if !HAVE_LIBINTL. */ |
7947 |
|
return (char *) gettext (re_error_msgid + re_error_msgid_idx[(int) ret]); |
7948 |
} |
} |
7949 |
|
|
7950 |
|
|
7951 |
int |
int |
7952 |
re_exec (s) |
#ifdef _LIBC |
7953 |
const char *s; |
weak_function |
7954 |
|
#endif |
7955 |
|
re_exec (const char *s) |
7956 |
{ |
{ |
7957 |
const int len = strlen (s); |
const int len = strlen (s); |
7958 |
return |
return |
7959 |
0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0); |
0 <= re_search (&re_comp_buf, s, len, 0, len, 0); |
7960 |
} |
} |
7961 |
|
|
7962 |
#endif /* _REGEX_RE_COMP */ |
#endif /* _REGEX_RE_COMP */ |
7963 |
|
|
7964 |
/* POSIX.2 functions. Don't define these for Emacs. */ |
/* POSIX.2 functions. Don't define these for Emacs. */ |
7976 |
REG_EXTENDED bit in CFLAGS is set; otherwise, to |
REG_EXTENDED bit in CFLAGS is set; otherwise, to |
7977 |
RE_SYNTAX_POSIX_BASIC; |
RE_SYNTAX_POSIX_BASIC; |
7978 |
`newline_anchor' to REG_NEWLINE being set in CFLAGS; |
`newline_anchor' to REG_NEWLINE being set in CFLAGS; |
7979 |
`fastmap' and `fastmap_accurate' to zero; |
`fastmap' to an allocated space for the fastmap; |
7980 |
|
`fastmap_accurate' to zero; |
7981 |
`re_nsub' to the number of subexpressions in PATTERN. |
`re_nsub' to the number of subexpressions in PATTERN. |
7982 |
|
|
7983 |
PATTERN is the address of the pattern string. |
PATTERN is the address of the pattern string. |
8001 |
the return codes and their meanings.) */ |
the return codes and their meanings.) */ |
8002 |
|
|
8003 |
int |
int |
8004 |
regcomp (preg, pattern, cflags) |
regcomp (regex_t *preg, const char *pattern, int cflags) |
|
regex_t *preg; |
|
|
const char *pattern; |
|
|
int cflags; |
|
8005 |
{ |
{ |
8006 |
reg_errcode_t ret; |
reg_errcode_t ret; |
8007 |
unsigned syntax |
reg_syntax_t syntax |
8008 |
= (cflags & REG_EXTENDED) ? |
= (cflags & REG_EXTENDED) ? |
8009 |
RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC; |
RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC; |
8010 |
|
|
8012 |
preg->buffer = 0; |
preg->buffer = 0; |
8013 |
preg->allocated = 0; |
preg->allocated = 0; |
8014 |
preg->used = 0; |
preg->used = 0; |
8015 |
|
|
8016 |
/* Don't bother to use a fastmap when searching. This simplifies the |
/* Try to allocate space for the fastmap. */ |
8017 |
REG_NEWLINE case: if we used a fastmap, we'd have to put all the |
preg->fastmap = malloc (1 << BYTEWIDTH); |
8018 |
characters after newlines into the fastmap. This way, we just try |
|
|
every character. */ |
|
|
preg->fastmap = 0; |
|
|
|
|
8019 |
if (cflags & REG_ICASE) |
if (cflags & REG_ICASE) |
8020 |
{ |
{ |
8021 |
unsigned i; |
unsigned i; |
8022 |
|
|
8023 |
preg->translate = (char *) malloc (CHAR_SET_SIZE); |
preg->translate = malloc (CHAR_SET_SIZE |
8024 |
|
* sizeof (*(RE_TRANSLATE_TYPE)0)); |
8025 |
if (preg->translate == NULL) |
if (preg->translate == NULL) |
8026 |
return (int) REG_ESPACE; |
return (int) REG_ESPACE; |
8027 |
|
|
8028 |
/* Map uppercase characters to corresponding lowercase ones. */ |
/* Map uppercase characters to corresponding lowercase ones. */ |
8029 |
for (i = 0; i < CHAR_SET_SIZE; i++) |
for (i = 0; i < CHAR_SET_SIZE; i++) |
8030 |
preg->translate[i] = ISUPPER (i) ? tolower (i) : i; |
preg->translate[i] = ISUPPER (i) ? TOLOWER (i) : i; |
8031 |
} |
} |
8032 |
else |
else |
8033 |
preg->translate = NULL; |
preg->translate = NULL; |
8045 |
|
|
8046 |
preg->no_sub = !!(cflags & REG_NOSUB); |
preg->no_sub = !!(cflags & REG_NOSUB); |
8047 |
|
|
8048 |
/* POSIX says a null character in the pattern terminates it, so we |
/* POSIX says a null character in the pattern terminates it, so we |
8049 |
can use strlen here in compiling the pattern. */ |
can use strlen here in compiling the pattern. */ |
8050 |
ret = regex_compile (pattern, strlen (pattern), syntax, preg); |
# ifdef MBS_SUPPORT |
8051 |
|
if (MB_CUR_MAX != 1) |
8052 |
|
ret = wcs_regex_compile (pattern, strlen (pattern), syntax, preg); |
8053 |
|
else |
8054 |
|
# endif |
8055 |
|
ret = byte_regex_compile (pattern, strlen (pattern), syntax, preg); |
8056 |
|
|
8057 |
/* POSIX doesn't distinguish between an unmatched open-group and an |
/* POSIX doesn't distinguish between an unmatched open-group and an |
8058 |
unmatched close-group: both are REG_EPAREN. */ |
unmatched close-group: both are REG_EPAREN. */ |
8059 |
if (ret == REG_ERPAREN) ret = REG_EPAREN; |
if (ret == REG_ERPAREN) ret = REG_EPAREN; |
8060 |
|
|
8061 |
|
if (ret == REG_NOERROR && preg->fastmap) |
8062 |
|
{ |
8063 |
|
/* Compute the fastmap now, since regexec cannot modify the pattern |
8064 |
|
buffer. */ |
8065 |
|
if (re_compile_fastmap (preg) == -2) |
8066 |
|
{ |
8067 |
|
/* Some error occurred while computing the fastmap, just forget |
8068 |
|
about it. */ |
8069 |
|
free (preg->fastmap); |
8070 |
|
preg->fastmap = NULL; |
8071 |
|
} |
8072 |
|
} |
8073 |
|
|
8074 |
return (int) ret; |
return (int) ret; |
8075 |
} |
} |
8076 |
|
#ifdef _LIBC |
8077 |
|
weak_alias (__regcomp, regcomp) |
8078 |
|
#endif |
8079 |
|
|
8080 |
|
|
8081 |
/* regexec searches for a given pattern, specified by PREG, in the |
/* regexec searches for a given pattern, specified by PREG, in the |
8082 |
string STRING. |
string STRING. |
8083 |
|
|
8084 |
If NMATCH is zero or REG_NOSUB was set in the cflags argument to |
If NMATCH is zero or REG_NOSUB was set in the cflags argument to |
8085 |
`regcomp', we ignore PMATCH. Otherwise, we assume PMATCH has at |
`regcomp', we ignore PMATCH. Otherwise, we assume PMATCH has at |
8086 |
least NMATCH elements, and we set them to the offsets of the |
least NMATCH elements, and we set them to the offsets of the |
8087 |
corresponding matched substrings. |
corresponding matched substrings. |
8088 |
|
|
8089 |
EFLAGS specifies `execution flags' which affect matching: if |
EFLAGS specifies `execution flags' which affect matching: if |
8090 |
REG_NOTBOL is set, then ^ does not match at the beginning of the |
REG_NOTBOL is set, then ^ does not match at the beginning of the |
8091 |
string; if REG_NOTEOL is set, then $ does not match at the end. |
string; if REG_NOTEOL is set, then $ does not match at the end. |
8092 |
|
|
8093 |
We return 0 if we find a match and REG_NOMATCH if not. */ |
We return 0 if we find a match and REG_NOMATCH if not. */ |
8094 |
|
|
8095 |
int |
int |
8096 |
regexec (preg, string, nmatch, pmatch, eflags) |
regexec (const regex_t *preg, const char *string, |
8097 |
const regex_t *preg; |
size_t nmatch, regmatch_t pmatch[], int eflags) |
|
const char *string; |
|
|
size_t nmatch; |
|
|
regmatch_t pmatch[]; |
|
|
int eflags; |
|
8098 |
{ |
{ |
8099 |
int ret; |
int ret; |
8100 |
struct re_registers regs; |
struct re_registers regs; |
8103 |
boolean want_reg_info = !preg->no_sub && nmatch > 0; |
boolean want_reg_info = !preg->no_sub && nmatch > 0; |
8104 |
|
|
8105 |
private_preg = *preg; |
private_preg = *preg; |
8106 |
|
|
8107 |
private_preg.not_bol = !!(eflags & REG_NOTBOL); |
private_preg.not_bol = !!(eflags & REG_NOTBOL); |
8108 |
private_preg.not_eol = !!(eflags & REG_NOTEOL); |
private_preg.not_eol = !!(eflags & REG_NOTEOL); |
8109 |
|
|
8110 |
/* The user has told us exactly how many registers to return |
/* The user has told us exactly how many registers to return |
8111 |
information about, via `nmatch'. We have to pass that on to the |
information about, via `nmatch'. We have to pass that on to the |
8112 |
matching routines. */ |
matching routines. */ |
8113 |
private_preg.regs_allocated = REGS_FIXED; |
private_preg.regs_allocated = REGS_FIXED; |
8114 |
|
|
8115 |
if (want_reg_info) |
if (want_reg_info) |
8116 |
{ |
{ |
8117 |
regs.num_regs = nmatch; |
regs.num_regs = nmatch; |
8118 |
regs.start = TALLOC (nmatch, regoff_t); |
regs.start = TALLOC (nmatch * 2, regoff_t); |
8119 |
regs.end = TALLOC (nmatch, regoff_t); |
if (regs.start == NULL) |
|
if (regs.start == NULL || regs.end == NULL) |
|
8120 |
return (int) REG_NOMATCH; |
return (int) REG_NOMATCH; |
8121 |
|
regs.end = regs.start + nmatch; |
8122 |
} |
} |
8123 |
|
|
8124 |
/* Perform the searching operation. */ |
/* Perform the searching operation. */ |
8125 |
ret = re_search (&private_preg, string, len, |
ret = re_search (&private_preg, string, len, |
8126 |
/* start: */ 0, /* range: */ len, |
/* start: */ 0, /* range: */ len, |
8127 |
want_reg_info ? ®s : (struct re_registers *) 0); |
want_reg_info ? ®s : 0); |
8128 |
|
|
8129 |
/* Copy the register information to the POSIX structure. */ |
/* Copy the register information to the POSIX structure. */ |
8130 |
if (want_reg_info) |
if (want_reg_info) |
8131 |
{ |
{ |
8142 |
|
|
8143 |
/* If we needed the temporary register info, free the space now. */ |
/* If we needed the temporary register info, free the space now. */ |
8144 |
free (regs.start); |
free (regs.start); |
|
free (regs.end); |
|
8145 |
} |
} |
8146 |
|
|
8147 |
/* We want zero return to mean success, unlike `re_search'. */ |
/* We want zero return to mean success, unlike `re_search'. */ |
8148 |
return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH; |
return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH; |
8149 |
} |
} |
8150 |
|
#ifdef _LIBC |
8151 |
|
weak_alias (__regexec, regexec) |
8152 |
|
#endif |
8153 |
|
|
8154 |
|
|
8155 |
/* Returns a message corresponding to an error code, ERRCODE, returned |
/* Returns a message corresponding to an error code, ERRCODE, returned |
8156 |
from either regcomp or regexec. We don't use PREG here. */ |
from either regcomp or regexec. We don't use PREG here. */ |
8157 |
|
|
8158 |
size_t |
size_t |
8159 |
regerror (errcode, preg, errbuf, errbuf_size) |
regerror (int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size) |
|
int errcode; |
|
|
const regex_t *preg; |
|
|
char *errbuf; |
|
|
size_t errbuf_size; |
|
8160 |
{ |
{ |
8161 |
const char *msg; |
const char *msg; |
8162 |
size_t msg_size; |
size_t msg_size; |
8163 |
|
|
8164 |
if (errcode < 0 |
if (errcode < 0 |
8165 |
|| errcode >= (sizeof (re_error_msg) / sizeof (re_error_msg[0]))) |
|| errcode >= (int) (sizeof (re_error_msgid_idx) |
8166 |
/* Only error codes returned by the rest of the code should be passed |
/ sizeof (re_error_msgid_idx[0]))) |
8167 |
|
/* Only error codes returned by the rest of the code should be passed |
8168 |
to this routine. If we are given anything else, or if other regex |
to this routine. If we are given anything else, or if other regex |
8169 |
code generates an invalid error code, then the program has a bug. |
code generates an invalid error code, then the program has a bug. |
8170 |
Dump core so we can fix it. */ |
Dump core so we can fix it. */ |
8171 |
abort (); |
abort (); |
8172 |
|
|
8173 |
msg = re_error_msg[errcode]; |
msg = gettext (re_error_msgid + re_error_msgid_idx[errcode]); |
|
|
|
|
/* POSIX doesn't require that we do anything in this case, but why |
|
|
not be nice. */ |
|
|
if (! msg) |
|
|
msg = "Success"; |
|
8174 |
|
|
8175 |
msg_size = strlen (msg) + 1; /* Includes the null. */ |
msg_size = strlen (msg) + 1; /* Includes the null. */ |
8176 |
|
|
8177 |
if (errbuf_size != 0) |
if (errbuf_size != 0) |
8178 |
{ |
{ |
8179 |
if (msg_size > errbuf_size) |
if (msg_size > errbuf_size) |
8180 |
{ |
{ |
8181 |
strncpy (errbuf, msg, errbuf_size - 1); |
#if defined HAVE_MEMPCPY || defined _LIBC |
8182 |
|
*((char *) __mempcpy (errbuf, msg, errbuf_size - 1)) = '\0'; |
8183 |
|
#else |
8184 |
|
memcpy (errbuf, msg, errbuf_size - 1); |
8185 |
errbuf[errbuf_size - 1] = 0; |
errbuf[errbuf_size - 1] = 0; |
8186 |
|
#endif |
8187 |
} |
} |
8188 |
else |
else |
8189 |
strcpy (errbuf, msg); |
memcpy (errbuf, msg, msg_size); |
8190 |
} |
} |
8191 |
|
|
8192 |
return msg_size; |
return msg_size; |
8193 |
} |
} |
8194 |
|
#ifdef _LIBC |
8195 |
|
weak_alias (__regerror, regerror) |
8196 |
|
#endif |
8197 |
|
|
8198 |
|
|
8199 |
/* Free dynamically allocated space used by PREG. */ |
/* Free dynamically allocated space used by PREG. */ |
8200 |
|
|
8201 |
void |
void |
8202 |
regfree (preg) |
regfree (regex_t *preg) |
|
regex_t *preg; |
|
8203 |
{ |
{ |
8204 |
if (preg->buffer != NULL) |
if (preg->buffer != NULL) |
8205 |
free (preg->buffer); |
free (preg->buffer); |
8206 |
preg->buffer = NULL; |
preg->buffer = NULL; |
8207 |
|
|
8208 |
preg->allocated = 0; |
preg->allocated = 0; |
8209 |
preg->used = 0; |
preg->used = 0; |
8210 |
|
|
8217 |
free (preg->translate); |
free (preg->translate); |
8218 |
preg->translate = NULL; |
preg->translate = NULL; |
8219 |
} |
} |
8220 |
|
#ifdef _LIBC |
8221 |
|
weak_alias (__regfree, regfree) |
8222 |
|
#endif |
8223 |
|
|
8224 |
#endif /* not emacs */ |
#endif /* not emacs */ |
8225 |
|
|
8226 |
|
#endif /* not INSIDE_RECURSION */ |
8227 |
|
|
8228 |
|
|
8229 |
/* |
#undef STORE_NUMBER |
8230 |
Local variables: |
#undef STORE_NUMBER_AND_INCR |
8231 |
make-backup-files: t |
#undef EXTRACT_NUMBER |
8232 |
version-control: t |
#undef EXTRACT_NUMBER_AND_INCR |
8233 |
trim-versions-without-asking: nil |
|
8234 |
End: |
#undef DEBUG_PRINT_COMPILED_PATTERN |
8235 |
*/ |
#undef DEBUG_PRINT_DOUBLE_STRING |
8236 |
|
|
8237 |
|
#undef INIT_FAIL_STACK |
8238 |
|
#undef RESET_FAIL_STACK |
8239 |
|
#undef DOUBLE_FAIL_STACK |
8240 |
|
#undef PUSH_PATTERN_OP |
8241 |
|
#undef PUSH_FAILURE_POINTER |
8242 |
|
#undef PUSH_FAILURE_INT |
8243 |
|
#undef PUSH_FAILURE_ELT |
8244 |
|
#undef POP_FAILURE_POINTER |
8245 |
|
#undef POP_FAILURE_INT |
8246 |
|
#undef POP_FAILURE_ELT |
8247 |
|
#undef DEBUG_PUSH |
8248 |
|
#undef DEBUG_POP |
8249 |
|
#undef PUSH_FAILURE_POINT |
8250 |
|
#undef POP_FAILURE_POINT |
8251 |
|
|
8252 |
|
#undef REG_UNSET_VALUE |
8253 |
|
#undef REG_UNSET |
8254 |
|
|
8255 |
|
#undef PATFETCH |
8256 |
|
#undef PATFETCH_RAW |
8257 |
|
#undef PATUNFETCH |
8258 |
|
#undef TRANSLATE |
8259 |
|
|
8260 |
|
#undef INIT_BUF_SIZE |
8261 |
|
#undef GET_BUFFER_SPACE |
8262 |
|
#undef BUF_PUSH |
8263 |
|
#undef BUF_PUSH_2 |
8264 |
|
#undef BUF_PUSH_3 |
8265 |
|
#undef STORE_JUMP |
8266 |
|
#undef STORE_JUMP2 |
8267 |
|
#undef INSERT_JUMP |
8268 |
|
#undef INSERT_JUMP2 |
8269 |
|
#undef EXTEND_BUFFER |
8270 |
|
#undef GET_UNSIGNED_NUMBER |
8271 |
|
#undef FREE_STACK_RETURN |
8272 |
|
|
8273 |
|
# undef POINTER_TO_OFFSET |
8274 |
|
# undef MATCHING_IN_FRST_STRING |
8275 |
|
# undef PREFETCH |
8276 |
|
# undef AT_STRINGS_BEG |
8277 |
|
# undef AT_STRINGS_END |
8278 |
|
# undef WORDCHAR_P |
8279 |
|
# undef FREE_VAR |
8280 |
|
# undef FREE_VARIABLES |
8281 |
|
# undef NO_HIGHEST_ACTIVE_REG |
8282 |
|
# undef NO_LOWEST_ACTIVE_REG |
8283 |
|
|
8284 |
|
# undef CHAR_T |
8285 |
|
# undef UCHAR_T |
8286 |
|
# undef COMPILED_BUFFER_VAR |
8287 |
|
# undef OFFSET_ADDRESS_SIZE |
8288 |
|
# undef CHAR_CLASS_SIZE |
8289 |
|
# undef PREFIX |
8290 |
|
# undef ARG_PREFIX |
8291 |
|
# undef PUT_CHAR |
8292 |
|
# undef BYTE |
8293 |
|
# undef WCHAR |
8294 |
|
|
8295 |
|
# define DEFINED_ONCE |