/[pcre]/code/trunk/pcre_internal.h
ViewVC logotype

Contents of /code/trunk/pcre_internal.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 884 - (hide annotations) (download)
Tue Jan 17 11:52:43 2012 UTC (2 years, 9 months ago) by zherczeg
File MIME type: text/plain
File size: 94319 byte(s)
JIT test prints cpu info
1 nigel 77 /*************************************************
2     * Perl-Compatible Regular Expressions *
3     *************************************************/
4    
5    
6     /* PCRE is a library of functions to support regular expressions whose syntax
7     and semantics are as close as possible to those of the Perl 5 language.
8    
9     Written by Philip Hazel
10 ph10 836 Copyright (c) 1997-2012 University of Cambridge
11 nigel 77
12     -----------------------------------------------------------------------------
13     Redistribution and use in source and binary forms, with or without
14     modification, are permitted provided that the following conditions are met:
15    
16     * Redistributions of source code must retain the above copyright notice,
17     this list of conditions and the following disclaimer.
18    
19     * Redistributions in binary form must reproduce the above copyright
20     notice, this list of conditions and the following disclaimer in the
21     documentation and/or other materials provided with the distribution.
22    
23     * Neither the name of the University of Cambridge nor the names of its
24     contributors may be used to endorse or promote products derived from
25     this software without specific prior written permission.
26    
27     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30     ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31     LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32     CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34     INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37     POSSIBILITY OF SUCH DAMAGE.
38     -----------------------------------------------------------------------------
39     */
40    
41     /* This header contains definitions that are shared between the different
42     modules, but which are not relevant to the exported API. This includes some
43 ph10 836 functions whose names all begin with "_pcre_" or "_pcre16_" depending on
44     the PRIV macro. */
45 nigel 77
46 nigel 85 #ifndef PCRE_INTERNAL_H
47     #define PCRE_INTERNAL_H
48 nigel 77
49 ph10 475 /* Define PCRE_DEBUG to get debugging output on stdout. */
50 nigel 77
51 nigel 85 #if 0
52 ph10 475 #define PCRE_DEBUG
53 nigel 85 #endif
54 nigel 77
55 ph10 836 /* PCRE is compiled as an 8 bit library if it is not requested otherwise. */
56     #ifndef COMPILE_PCRE16
57     #define COMPILE_PCRE8
58 ph10 391 #endif
59    
60 ph10 836 /* If SUPPORT_UCP is defined, SUPPORT_UTF must also be defined. The
61 ph10 393 "configure" script ensures this, but not everybody uses "configure". */
62    
63 ph10 836 #if defined SUPPORT_UCP && !(defined SUPPORT_UTF)
64     #define SUPPORT_UTF 1
65     #endif
66    
67     /* We define SUPPORT_UTF if SUPPORT_UTF8 is enabled for compatibility
68     reasons with existing code. */
69    
70     #if defined SUPPORT_UTF8 && !(defined SUPPORT_UTF)
71     #define SUPPORT_UTF 1
72     #endif
73    
74     /* Fixme: SUPPORT_UTF8 should be eventually disappear from the code.
75     Until then we define it if SUPPORT_UTF is defined. */
76    
77     #if defined SUPPORT_UTF && !(defined SUPPORT_UTF8)
78 ph10 393 #define SUPPORT_UTF8 1
79     #endif
80    
81 ph10 836 /* We do not support both EBCDIC and UTF-8/16 at the same time. The "configure"
82     script prevents both being selected, but not everybody uses "configure". */
83    
84     #if defined EBCDIC && defined SUPPORT_UTF
85     #error The use of both EBCDIC and SUPPORT_UTF8/16 is not supported.
86     #endif
87    
88 nigel 77 /* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
89     inline, and there are *still* stupid compilers about that don't like indented
90     pre-processor statements, or at least there were when I first wrote this. After
91 nigel 93 all, it had only been about 10 years then...
92 nigel 77
93 nigel 93 It turns out that the Mac Debugging.h header also defines the macro DPRINTF, so
94     be absolutely sure we get our version. */
95    
96     #undef DPRINTF
97 ph10 475 #ifdef PCRE_DEBUG
98 nigel 77 #define DPRINTF(p) printf p
99     #else
100 nigel 93 #define DPRINTF(p) /* Nothing */
101 nigel 77 #endif
102    
103    
104     /* Standard C headers plus the external interface definition. The only time
105     setjmp and stdarg are used is when NO_RECURSE is set. */
106    
107     #include <ctype.h>
108     #include <limits.h>
109     #include <stddef.h>
110     #include <stdio.h>
111     #include <stdlib.h>
112     #include <string.h>
113    
114 ph10 145 /* When compiling a DLL for Windows, the exported symbols have to be declared
115     using some MS magic. I found some useful information on this web page:
116     http://msdn2.microsoft.com/en-us/library/y4h7bcy6(VS.80).aspx. According to the
117 ph10 154 information there, using __declspec(dllexport) without "extern" we have a
118 ph10 145 definition; with "extern" we have a declaration. The settings here override the
119     setting in pcre.h (which is included below); it defines only PCRE_EXP_DECL,
120 ph10 154 which is all that is needed for applications (they just import the symbols). We
121     use:
122 ph10 145
123     PCRE_EXP_DECL for declarations
124     PCRE_EXP_DEFN for definitions of exported functions
125     PCRE_EXP_DATA_DEFN for definitions of exported variables
126    
127     The reason for the two DEFN macros is that in non-Windows environments, one
128     does not want to have "extern" before variable definitions because it leads to
129     compiler warnings. So we distinguish between functions and variables. In
130     Windows, the two should always be the same.
131    
132     The reason for wrapping this in #ifndef PCRE_EXP_DECL is so that pcretest,
133     which is an application, but needs to import this file in order to "peek" at
134 ph10 154 internals, can #include pcre.h first to get an application's-eye view.
135 ph10 145
136     In principle, people compiling for non-Windows, non-Unix-like (i.e. uncommon,
137     special-purpose environments) might want to stick other stuff in front of
138     exported symbols. That's why, in the non-Windows case, we set PCRE_EXP_DEFN and
139     PCRE_EXP_DATA_DEFN only if they are not already set. */
140    
141     #ifndef PCRE_EXP_DECL
142     # ifdef _WIN32
143 ph10 199 # ifndef PCRE_STATIC
144 ph10 145 # define PCRE_EXP_DECL extern __declspec(dllexport)
145     # define PCRE_EXP_DEFN __declspec(dllexport)
146     # define PCRE_EXP_DATA_DEFN __declspec(dllexport)
147     # else
148     # define PCRE_EXP_DECL extern
149     # define PCRE_EXP_DEFN
150     # define PCRE_EXP_DATA_DEFN
151     # endif
152     # else
153     # ifdef __cplusplus
154     # define PCRE_EXP_DECL extern "C"
155     # else
156     # define PCRE_EXP_DECL extern
157     # endif
158     # ifndef PCRE_EXP_DEFN
159     # define PCRE_EXP_DEFN PCRE_EXP_DECL
160     # endif
161     # ifndef PCRE_EXP_DATA_DEFN
162     # define PCRE_EXP_DATA_DEFN
163     # endif
164     # endif
165 nigel 77 #endif
166    
167 ph10 359 /* When compiling with the MSVC compiler, it is sometimes necessary to include
168 ph10 371 a "calling convention" before exported function names. (This is secondhand
169 ph10 359 information; I know nothing about MSVC myself). For example, something like
170    
171     void __cdecl function(....)
172 ph10 371
173 ph10 359 might be needed. In order so make this easy, all the exported functions have
174     PCRE_CALL_CONVENTION just before their names. It is rarely needed; if not
175 ph10 371 set, we ensure here that it has no effect. */
176 ph10 359
177     #ifndef PCRE_CALL_CONVENTION
178     #define PCRE_CALL_CONVENTION
179     #endif
180    
181 ph10 836 /* We need to have types that specify unsigned 8, 16 and 32-bit integers. We
182 nigel 77 cannot determine these outside the compilation (e.g. by running a program as
183     part of "configure") because PCRE is often cross-compiled for use on other
184     systems. Instead we make use of the maximum sizes that are available at
185     preprocessor time in standard C environments. */
186    
187 ph10 836 typedef unsigned char pcre_uint8;
188    
189 nigel 77 #if USHRT_MAX == 65535
190     typedef unsigned short pcre_uint16;
191 ph10 349 typedef short pcre_int16;
192 nigel 77 #elif UINT_MAX == 65535
193     typedef unsigned int pcre_uint16;
194 ph10 349 typedef int pcre_int16;
195 nigel 77 #else
196     #error Cannot determine a type for 16-bit unsigned integers
197     #endif
198    
199     #if UINT_MAX == 4294967295
200     typedef unsigned int pcre_uint32;
201 ph10 349 typedef int pcre_int32;
202 nigel 77 #elif ULONG_MAX == 4294967295
203     typedef unsigned long int pcre_uint32;
204 ph10 349 typedef long int pcre_int32;
205 nigel 77 #else
206     #error Cannot determine a type for 32-bit unsigned integers
207     #endif
208    
209 ph10 487 /* When checking for integer overflow in pcre_compile(), we need to handle
210     large integers. If a 64-bit integer type is available, we can use that.
211     Otherwise we have to cast to double, which of course requires floating point
212     arithmetic. Handle this by defining a macro for the appropriate type. If
213 ph10 494 stdint.h is available, include it; it may define INT64_MAX. Systems that do not
214     have stdint.h (e.g. Solaris) may have inttypes.h. The macro int64_t may be set
215     by "configure". */
216 ph10 475
217     #if HAVE_STDINT_H
218     #include <stdint.h>
219 ph10 494 #elif HAVE_INTTYPES_H
220     #include <inttypes.h>
221 ph10 475 #endif
222    
223     #if defined INT64_MAX || defined int64_t
224     #define INT64_OR_DOUBLE int64_t
225     #else
226     #define INT64_OR_DOUBLE double
227     #endif
228    
229 nigel 77 /* All character handling must be done as unsigned characters. Otherwise there
230     are problems with top-bit-set characters and functions such as isspace().
231 ph10 836 However, we leave the interface to the outside world as char * or short *,
232     because that should make things easier for callers. This character type is
233     called pcre_uchar.
234 nigel 77
235 ph10 836 The IN_UCHARS macro multiply its argument with the byte size of the current
236     pcre_uchar type. Useful for memcpy and such operations, whose require the
237     byte size of their input/output buffers.
238 nigel 77
239 ph10 836 The MAX_255 macro checks whether its pcre_uchar input is less than 256.
240    
241     The TABLE_GET macro is designed for accessing elements of tables whose contain
242     exactly 256 items. When the character is able to contain more than 256
243     items, some check is needed before accessing these tables.
244     */
245    
246     #ifdef COMPILE_PCRE8
247    
248     typedef unsigned char pcre_uchar;
249     #define IN_UCHARS(x) (x)
250     #define MAX_255(c) 1
251     #define TABLE_GET(c, table, default) ((table)[c])
252    
253     #else
254    
255     #ifdef COMPILE_PCRE16
256     #if USHRT_MAX != 65535
257 zherczeg 860 /* This is a warning message. Change PCRE_UCHAR16 to a 16 bit data type in
258 ph10 836 pcre.h(.in) and disable (comment out) this message. */
259 zherczeg 860 #error Warning: PCRE_UCHAR16 is not a 16 bit data type.
260 ph10 836 #endif
261    
262     typedef pcre_uint16 pcre_uchar;
263     #define IN_UCHARS(x) ((x) << 1)
264     #define MAX_255(c) ((c) <= 255u)
265     #define TABLE_GET(c, table, default) (MAX_255(c)? ((table)[c]):(default))
266    
267     #else
268     #error Unsupported compiling mode
269     #endif /* COMPILE_PCRE16 */
270    
271     #endif /* COMPILE_PCRE8 */
272    
273 nigel 93 /* This is an unsigned int value that no character can ever have. UTF-8
274     characters only go up to 0x7fffffff (though Unicode doesn't go beyond
275     0x0010ffff). */
276 nigel 91
277 nigel 93 #define NOTACHAR 0xffffffff
278    
279     /* PCRE is able to support several different kinds of newline (CR, LF, CRLF,
280 ph10 149 "any" and "anycrlf" at present). The following macros are used to package up
281     testing for newlines. NLBLOCK, PSSTART, and PSEND are defined in the various
282     modules to indicate in which datablock the parameters exist, and what the
283     start/end of string field names are. */
284 nigel 93
285 ph10 149 #define NLTYPE_FIXED 0 /* Newline is a fixed length string */
286     #define NLTYPE_ANY 1 /* Newline is any Unicode line ending */
287     #define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */
288 nigel 93
289     /* This macro checks for a newline at the given position */
290    
291 nigel 91 #define IS_NEWLINE(p) \
292 nigel 93 ((NLBLOCK->nltype != NLTYPE_FIXED)? \
293     ((p) < NLBLOCK->PSEND && \
294 ph10 836 PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \
295     &(NLBLOCK->nllen), utf)) \
296 nigel 93 : \
297     ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \
298     (p)[0] == NLBLOCK->nl[0] && \
299     (NLBLOCK->nllen == 1 || (p)[1] == NLBLOCK->nl[1]) \
300     ) \
301     )
302 nigel 91
303 nigel 93 /* This macro checks for a newline immediately preceding the given position */
304    
305     #define WAS_NEWLINE(p) \
306     ((NLBLOCK->nltype != NLTYPE_FIXED)? \
307     ((p) > NLBLOCK->PSSTART && \
308 ph10 836 PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \
309     &(NLBLOCK->nllen), utf)) \
310 nigel 93 : \
311     ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \
312     (p)[-NLBLOCK->nllen] == NLBLOCK->nl[0] && \
313     (NLBLOCK->nllen == 1 || (p)[-NLBLOCK->nllen+1] == NLBLOCK->nl[1]) \
314     ) \
315     )
316    
317 nigel 87 /* When PCRE is compiled as a C++ library, the subject pointer can be replaced
318     with a custom type. This makes it possible, for example, to allow pcre_exec()
319     to process subject strings that are discontinuous by using a smart pointer
320     class. It must always be possible to inspect all of the subject string in
321     pcre_exec() because of the way it backtracks. Two macros are required in the
322     normal case, for sign-unspecified and unsigned char pointers. The former is
323     used for the external interface and appears in pcre.h, which is why its name
324     must begin with PCRE_. */
325    
326     #ifdef CUSTOM_SUBJECT_PTR
327 ph10 836 #define PCRE_PUCHAR CUSTOM_SUBJECT_PTR
328 nigel 87 #else
329 ph10 836 #define PCRE_PUCHAR const pcre_uchar *
330 nigel 87 #endif
331    
332 nigel 85 /* Include the public PCRE header and the definitions of UCP character property
333     values. */
334 nigel 77
335 ph10 189 #include "pcre.h"
336 nigel 77 #include "ucp.h"
337    
338     /* When compiling for use with the Virtual Pascal compiler, these functions
339     need to have their names changed. PCRE must be compiled with the -DVPCOMPAT
340     option on the command line. */
341    
342     #ifdef VPCOMPAT
343 ph10 101 #define strlen(s) _strlen(s)
344 nigel 77 #define strncmp(s1,s2,m) _strncmp(s1,s2,m)
345 ph10 101 #define memcmp(s,c,n) _memcmp(s,c,n)
346 nigel 77 #define memcpy(d,s,n) _memcpy(d,s,n)
347     #define memmove(d,s,n) _memmove(d,s,n)
348     #define memset(s,c,n) _memset(s,c,n)
349     #else /* VPCOMPAT */
350    
351     /* To cope with SunOS4 and other systems that lack memmove() but have bcopy(),
352     define a macro for memmove() if HAVE_MEMMOVE is false, provided that HAVE_BCOPY
353     is set. Otherwise, include an emulating function for those systems that have
354 ph10 118 neither (there some non-Unix environments where this is the case). */
355 nigel 77
356 ph10 137 #ifndef HAVE_MEMMOVE
357 nigel 77 #undef memmove /* some systems may have a macro */
358 ph10 137 #ifdef HAVE_BCOPY
359 nigel 77 #define memmove(a, b, c) bcopy(b, a, c)
360     #else /* HAVE_BCOPY */
361 nigel 91 static void *
362 ph10 108 pcre_memmove(void *d, const void *s, size_t n)
363 nigel 77 {
364 nigel 87 size_t i;
365 ph10 108 unsigned char *dest = (unsigned char *)d;
366     const unsigned char *src = (const unsigned char *)s;
367 ph10 118 if (dest > src)
368     {
369     dest += n;
370     src += n;
371     for (i = 0; i < n; ++i) *(--dest) = *(--src);
372     return (void *)dest;
373     }
374     else
375     {
376     for (i = 0; i < n; ++i) *dest++ = *src++;
377 ph10 123 return (void *)(dest - n);
378     }
379 nigel 77 }
380     #define memmove(a, b, c) pcre_memmove(a, b, c)
381     #endif /* not HAVE_BCOPY */
382     #endif /* not HAVE_MEMMOVE */
383     #endif /* not VPCOMPAT */
384    
385    
386     /* PCRE keeps offsets in its compiled code as 2-byte quantities (always stored
387     in big-endian order) by default. These are used, for example, to link from the
388     start of a subpattern to its alternatives and its end. The use of 2 bytes per
389     offset limits the size of the compiled regex to around 64K, which is big enough
390     for almost everybody. However, I received a request for an even bigger limit.
391     For this reason, and also to make the code easier to maintain, the storing and
392     loading of offsets from the byte string is now handled by the macros that are
393     defined here.
394    
395     The macros are controlled by the value of LINK_SIZE. This defaults to 2 in
396     the config.h file, but can be overridden by using -D on the command line. This
397     is automated on Unix systems via the "configure" command. */
398    
399 ph10 836 #ifdef COMPILE_PCRE8
400    
401 nigel 77 #if LINK_SIZE == 2
402    
403     #define PUT(a,n,d) \
404     (a[n] = (d) >> 8), \
405     (a[(n)+1] = (d) & 255)
406    
407     #define GET(a,n) \
408     (((a)[n] << 8) | (a)[(n)+1])
409    
410     #define MAX_PATTERN_SIZE (1 << 16)
411    
412    
413     #elif LINK_SIZE == 3
414    
415     #define PUT(a,n,d) \
416     (a[n] = (d) >> 16), \
417     (a[(n)+1] = (d) >> 8), \
418     (a[(n)+2] = (d) & 255)
419    
420     #define GET(a,n) \
421     (((a)[n] << 16) | ((a)[(n)+1] << 8) | (a)[(n)+2])
422    
423     #define MAX_PATTERN_SIZE (1 << 24)
424    
425    
426     #elif LINK_SIZE == 4
427    
428     #define PUT(a,n,d) \
429     (a[n] = (d) >> 24), \
430     (a[(n)+1] = (d) >> 16), \
431     (a[(n)+2] = (d) >> 8), \
432     (a[(n)+3] = (d) & 255)
433    
434     #define GET(a,n) \
435     (((a)[n] << 24) | ((a)[(n)+1] << 16) | ((a)[(n)+2] << 8) | (a)[(n)+3])
436    
437 ph10 836 /* Keep it positive */
438     #define MAX_PATTERN_SIZE (1 << 30)
439 nigel 77
440 ph10 836 #else
441     #error LINK_SIZE must be either 2, 3, or 4
442     #endif
443 nigel 77
444 ph10 836 #else /* COMPILE_PCRE8 */
445    
446     #ifdef COMPILE_PCRE16
447    
448     #if LINK_SIZE == 2
449    
450     #undef LINK_SIZE
451     #define LINK_SIZE 1
452    
453     #define PUT(a,n,d) \
454     (a[n] = (d))
455    
456     #define GET(a,n) \
457     (a[n])
458    
459     #define MAX_PATTERN_SIZE (1 << 16)
460    
461     #elif LINK_SIZE == 3 || LINK_SIZE == 4
462    
463     #undef LINK_SIZE
464     #define LINK_SIZE 2
465    
466     #define PUT(a,n,d) \
467     (a[n] = (d) >> 16), \
468     (a[(n)+1] = (d) & 65535)
469    
470     #define GET(a,n) \
471     (((a)[n] << 16) | (a)[(n)+1])
472    
473     /* Keep it positive */
474     #define MAX_PATTERN_SIZE (1 << 30)
475    
476 nigel 77 #else
477     #error LINK_SIZE must be either 2, 3, or 4
478     #endif
479    
480 ph10 836 #else
481     #error Unsupported compiling mode
482     #endif /* COMPILE_PCRE16 */
483 nigel 77
484 ph10 836 #endif /* COMPILE_PCRE8 */
485    
486 nigel 77 /* Convenience macro defined in terms of the others */
487    
488     #define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE
489    
490    
491     /* PCRE uses some other 2-byte quantities that do not change when the size of
492     offsets changes. There are used for repeat counts and for other things such as
493     capturing parenthesis numbers in back references. */
494    
495 ph10 836 #ifdef COMPILE_PCRE8
496    
497     #define IMM2_SIZE 2
498    
499 nigel 77 #define PUT2(a,n,d) \
500     a[n] = (d) >> 8; \
501     a[(n)+1] = (d) & 255
502    
503     #define GET2(a,n) \
504     (((a)[n] << 8) | (a)[(n)+1])
505    
506 ph10 836 #else /* COMPILE_PCRE8 */
507 nigel 77
508 ph10 836 #ifdef COMPILE_PCRE16
509 nigel 77
510 ph10 836 #define IMM2_SIZE 1
511 nigel 77
512 ph10 836 #define PUT2(a,n,d) \
513     a[n] = d
514    
515     #define GET2(a,n) \
516     a[n]
517    
518     #else
519     #error Unsupported compiling mode
520     #endif /* COMPILE_PCRE16 */
521    
522     #endif /* COMPILE_PCRE8 */
523    
524     #define PUT2INC(a,n,d) PUT2(a,n,d), a += IMM2_SIZE
525    
526     /* When UTF encoding is being used, a character is no longer just a single
527     character. The macros for character handling generate simple sequences when
528     used in character-mode, and more complicated ones for UTF characters.
529     GETCHARLENTEST and other macros are not used when UTF is not supported,
530     so they are not defined. To make sure they can never even appear when
531     UTF support is omitted, we don't even define them. */
532    
533     #ifndef SUPPORT_UTF
534    
535     /* #define MAX_VALUE_FOR_SINGLE_CHAR */
536     /* #define HAS_EXTRALEN(c) */
537     /* #define GET_EXTRALEN(c) */
538     /* #define NOT_FIRSTCHAR(c) */
539 nigel 77 #define GETCHAR(c, eptr) c = *eptr;
540     #define GETCHARTEST(c, eptr) c = *eptr;
541     #define GETCHARINC(c, eptr) c = *eptr++;
542     #define GETCHARINCTEST(c, eptr) c = *eptr++;
543     #define GETCHARLEN(c, eptr, len) c = *eptr;
544 ph10 573 /* #define GETCHARLENTEST(c, eptr, len) */
545 ph10 207 /* #define BACKCHAR(eptr) */
546 ph10 836 /* #define FORWARDCHAR(eptr) */
547     /* #define ACROSSCHAR(condition, eptr, action) */
548 nigel 77
549 ph10 836 #else /* SUPPORT_UTF */
550 nigel 77
551 ph10 836 #ifdef COMPILE_PCRE8
552    
553 ph10 573 /* These macros were originally written in the form of loops that used data
554 ph10 836 from the tables whose names start with PRIV(utf8_table). They were rewritten by
555 ph10 573 a user so as not to use loops, because in some environments this gives a
556     significant performance advantage, and it seems never to do any harm. */
557    
558 ph10 836 /* Tells the biggest code point which can be encoded as a single character. */
559    
560     #define MAX_VALUE_FOR_SINGLE_CHAR 127
561    
562     /* Tests whether the code point needs extra characters to decode. */
563    
564     #define HAS_EXTRALEN(c) ((c) >= 0xc0)
565    
566     /* Returns with the additional number of characters if IS_MULTICHAR(c) is TRUE.
567     Otherwise it has an undefined behaviour. */
568    
569     #define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3f])
570    
571     /* Returns TRUE, if the given character is not the first character
572     of a UTF sequence. */
573    
574     #define NOT_FIRSTCHAR(c) (((c) & 0xc0) == 0x80)
575    
576 ph10 573 /* Base macro to pick up the remaining bytes of a UTF-8 character, not
577     advancing the pointer. */
578    
579     #define GETUTF8(c, eptr) \
580     { \
581     if ((c & 0x20) == 0) \
582     c = ((c & 0x1f) << 6) | (eptr[1] & 0x3f); \
583     else if ((c & 0x10) == 0) \
584     c = ((c & 0x0f) << 12) | ((eptr[1] & 0x3f) << 6) | (eptr[2] & 0x3f); \
585     else if ((c & 0x08) == 0) \
586     c = ((c & 0x07) << 18) | ((eptr[1] & 0x3f) << 12) | \
587     ((eptr[2] & 0x3f) << 6) | (eptr[3] & 0x3f); \
588     else if ((c & 0x04) == 0) \
589     c = ((c & 0x03) << 24) | ((eptr[1] & 0x3f) << 18) | \
590     ((eptr[2] & 0x3f) << 12) | ((eptr[3] & 0x3f) << 6) | \
591     (eptr[4] & 0x3f); \
592     else \
593     c = ((c & 0x01) << 30) | ((eptr[1] & 0x3f) << 24) | \
594     ((eptr[2] & 0x3f) << 18) | ((eptr[3] & 0x3f) << 12) | \
595     ((eptr[4] & 0x3f) << 6) | (eptr[5] & 0x3f); \
596     }
597    
598 nigel 77 /* Get the next UTF-8 character, not advancing the pointer. This is called when
599     we know we are in UTF-8 mode. */
600    
601     #define GETCHAR(c, eptr) \
602     c = *eptr; \
603 ph10 573 if (c >= 0xc0) GETUTF8(c, eptr);
604 nigel 77
605     /* Get the next UTF-8 character, testing for UTF-8 mode, and not advancing the
606     pointer. */
607    
608     #define GETCHARTEST(c, eptr) \
609     c = *eptr; \
610 ph10 836 if (utf && c >= 0xc0) GETUTF8(c, eptr);
611 ph10 573
612     /* Base macro to pick up the remaining bytes of a UTF-8 character, advancing
613     the pointer. */
614    
615     #define GETUTF8INC(c, eptr) \
616 nigel 77 { \
617 ph10 573 if ((c & 0x20) == 0) \
618     c = ((c & 0x1f) << 6) | (*eptr++ & 0x3f); \
619     else if ((c & 0x10) == 0) \
620 nigel 77 { \
621 ph10 573 c = ((c & 0x0f) << 12) | ((*eptr & 0x3f) << 6) | (eptr[1] & 0x3f); \
622     eptr += 2; \
623 nigel 77 } \
624 ph10 573 else if ((c & 0x08) == 0) \
625     { \
626     c = ((c & 0x07) << 18) | ((*eptr & 0x3f) << 12) | \
627     ((eptr[1] & 0x3f) << 6) | (eptr[2] & 0x3f); \
628     eptr += 3; \
629     } \
630     else if ((c & 0x04) == 0) \
631     { \
632     c = ((c & 0x03) << 24) | ((*eptr & 0x3f) << 18) | \
633     ((eptr[1] & 0x3f) << 12) | ((eptr[2] & 0x3f) << 6) | \
634     (eptr[3] & 0x3f); \
635     eptr += 4; \
636     } \
637     else \
638     { \
639     c = ((c & 0x01) << 30) | ((*eptr & 0x3f) << 24) | \
640     ((eptr[1] & 0x3f) << 18) | ((eptr[2] & 0x3f) << 12) | \
641     ((eptr[3] & 0x3f) << 6) | (eptr[4] & 0x3f); \
642     eptr += 5; \
643     } \
644 nigel 77 }
645    
646     /* Get the next UTF-8 character, advancing the pointer. This is called when we
647     know we are in UTF-8 mode. */
648    
649     #define GETCHARINC(c, eptr) \
650     c = *eptr++; \
651 ph10 573 if (c >= 0xc0) GETUTF8INC(c, eptr);
652 nigel 77
653 ph10 529 /* Get the next character, testing for UTF-8 mode, and advancing the pointer.
654     This is called when we don't know if we are in UTF-8 mode. */
655 nigel 77
656     #define GETCHARINCTEST(c, eptr) \
657     c = *eptr++; \
658 ph10 836 if (utf && c >= 0xc0) GETUTF8INC(c, eptr);
659 ph10 573
660     /* Base macro to pick up the remaining bytes of a UTF-8 character, not
661     advancing the pointer, incrementing the length. */
662    
663     #define GETUTF8LEN(c, eptr, len) \
664 nigel 77 { \
665 ph10 573 if ((c & 0x20) == 0) \
666 nigel 77 { \
667 ph10 573 c = ((c & 0x1f) << 6) | (eptr[1] & 0x3f); \
668     len++; \
669 nigel 77 } \
670 ph10 573 else if ((c & 0x10) == 0) \
671     { \
672     c = ((c & 0x0f) << 12) | ((eptr[1] & 0x3f) << 6) | (eptr[2] & 0x3f); \
673     len += 2; \
674     } \
675     else if ((c & 0x08) == 0) \
676     {\
677     c = ((c & 0x07) << 18) | ((eptr[1] & 0x3f) << 12) | \
678     ((eptr[2] & 0x3f) << 6) | (eptr[3] & 0x3f); \
679     len += 3; \
680     } \
681     else if ((c & 0x04) == 0) \
682     { \
683     c = ((c & 0x03) << 24) | ((eptr[1] & 0x3f) << 18) | \
684     ((eptr[2] & 0x3f) << 12) | ((eptr[3] & 0x3f) << 6) | \
685     (eptr[4] & 0x3f); \
686     len += 4; \
687     } \
688     else \
689     {\
690     c = ((c & 0x01) << 30) | ((eptr[1] & 0x3f) << 24) | \
691     ((eptr[2] & 0x3f) << 18) | ((eptr[3] & 0x3f) << 12) | \
692     ((eptr[4] & 0x3f) << 6) | (eptr[5] & 0x3f); \
693     len += 5; \
694     } \
695 nigel 77 }
696    
697     /* Get the next UTF-8 character, not advancing the pointer, incrementing length
698     if there are extra bytes. This is called when we know we are in UTF-8 mode. */
699    
700     #define GETCHARLEN(c, eptr, len) \
701     c = *eptr; \
702 ph10 573 if (c >= 0xc0) GETUTF8LEN(c, eptr, len);
703 nigel 77
704 ph10 384 /* Get the next UTF-8 character, testing for UTF-8 mode, not advancing the
705     pointer, incrementing length if there are extra bytes. This is called when we
706 ph10 529 do not know if we are in UTF-8 mode. */
707 ph10 384
708     #define GETCHARLENTEST(c, eptr, len) \
709     c = *eptr; \
710 ph10 836 if (utf && c >= 0xc0) GETUTF8LEN(c, eptr, len);
711 ph10 384
712 nigel 77 /* If the pointer is not at the start of a character, move it back until
713 ph10 208 it is. This is called only in UTF-8 mode - we don't put a test within the macro
714 ph10 207 because almost all calls are already within a block of UTF-8 only code. */
715 nigel 77
716 ph10 207 #define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--
717 nigel 77
718 ph10 836 /* Same as above, just in the other direction. */
719     #define FORWARDCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr++
720 nigel 77
721 ph10 836 /* Same as above, but it allows a fully customizable form. */
722     #define ACROSSCHAR(condition, eptr, action) \
723     while((condition) && ((eptr) & 0xc0) == 0x80) action
724 nigel 77
725 ph10 836 #else /* COMPILE_PCRE8 */
726    
727     #ifdef COMPILE_PCRE16
728    
729     /* Tells the biggest code point which can be encoded as a single character. */
730    
731     #define MAX_VALUE_FOR_SINGLE_CHAR 65535
732    
733     /* Tests whether the code point needs extra characters to decode. */
734    
735     #define HAS_EXTRALEN(c) (((c) & 0xfc00) == 0xd800)
736    
737     /* Returns with the additional number of characters if IS_MULTICHAR(c) is TRUE.
738     Otherwise it has an undefined behaviour. */
739    
740     #define GET_EXTRALEN(c) 1
741    
742     /* Returns TRUE, if the given character is not the first character
743     of a UTF sequence. */
744    
745     #define NOT_FIRSTCHAR(c) (((c) & 0xfc00) == 0xdc00)
746    
747     /* Base macro to pick up the low surrogate of a UTF-16 character, not
748     advancing the pointer. */
749    
750     #define GETUTF16(c, eptr) \
751     { c = (((c & 0x3ff) << 10) | (eptr[1] & 0x3ff)) + 0x10000; }
752    
753     /* Get the next UTF-16 character, not advancing the pointer. This is called when
754     we know we are in UTF-16 mode. */
755    
756     #define GETCHAR(c, eptr) \
757     c = *eptr; \
758     if ((c & 0xfc00) == 0xd800) GETUTF16(c, eptr);
759    
760     /* Get the next UTF-16 character, testing for UTF-16 mode, and not advancing the
761     pointer. */
762    
763     #define GETCHARTEST(c, eptr) \
764     c = *eptr; \
765     if (utf && (c & 0xfc00) == 0xd800) GETUTF16(c, eptr);
766    
767     /* Base macro to pick up the low surrogate of a UTF-16 character, advancing
768     the pointer. */
769    
770     #define GETUTF16INC(c, eptr) \
771     { c = (((c & 0x3ff) << 10) | (*eptr++ & 0x3ff)) + 0x10000; }
772    
773     /* Get the next UTF-16 character, advancing the pointer. This is called when we
774     know we are in UTF-16 mode. */
775    
776     #define GETCHARINC(c, eptr) \
777     c = *eptr++; \
778     if ((c & 0xfc00) == 0xd800) GETUTF16INC(c, eptr);
779    
780     /* Get the next character, testing for UTF-16 mode, and advancing the pointer.
781     This is called when we don't know if we are in UTF-16 mode. */
782    
783     #define GETCHARINCTEST(c, eptr) \
784     c = *eptr++; \
785     if (utf && (c & 0xfc00) == 0xd800) GETUTF16INC(c, eptr);
786    
787     /* Base macro to pick up the low surrogate of a UTF-16 character, not
788     advancing the pointer, incrementing the length. */
789    
790     #define GETUTF16LEN(c, eptr, len) \
791     { c = (((c & 0x3ff) << 10) | (eptr[1] & 0x3ff)) + 0x10000; len++; }
792    
793     /* Get the next UTF-16 character, not advancing the pointer, incrementing
794     length if there is a low surrogate. This is called when we know we are in
795     UTF-16 mode. */
796    
797     #define GETCHARLEN(c, eptr, len) \
798     c = *eptr; \
799     if ((c & 0xfc00) == 0xd800) GETUTF16LEN(c, eptr, len);
800    
801     /* Get the next UTF-816character, testing for UTF-16 mode, not advancing the
802     pointer, incrementing length if there is a low surrogate. This is called when
803     we do not know if we are in UTF-16 mode. */
804    
805     #define GETCHARLENTEST(c, eptr, len) \
806     c = *eptr; \
807     if (utf && (c & 0xfc00) == 0xd800) GETUTF16LEN(c, eptr, len);
808    
809     /* If the pointer is not at the start of a character, move it back until
810     it is. This is called only in UTF-16 mode - we don't put a test within the
811     macro because almost all calls are already within a block of UTF-16 only
812     code. */
813    
814     #define BACKCHAR(eptr) if ((*eptr & 0xfc00) == 0xdc00) eptr--
815    
816     /* Same as above, just in the other direction. */
817     #define FORWARDCHAR(eptr) if ((*eptr & 0xfc00) == 0xdc00) eptr++
818    
819     /* Same as above, but it allows a fully customizable form. */
820     #define ACROSSCHAR(condition, eptr, action) \
821     if ((condition) && ((eptr) & 0xfc00) == 0xdc00) action
822    
823     #endif
824    
825     #endif /* COMPILE_PCRE8 */
826    
827     #endif /* SUPPORT_UTF */
828    
829    
830 nigel 77 /* In case there is no definition of offsetof() provided - though any proper
831     Standard C system should have one. */
832    
833     #ifndef offsetof
834     #define offsetof(p_type,field) ((size_t)&(((p_type *)0)->field))
835     #endif
836    
837    
838 ph10 231 /* Private flags containing information about the compiled regex. They used to
839     live at the top end of the options word, but that got almost full, so now they
840 ph10 426 are in a 16-bit flags word. From release 8.00, PCRE_NOPARTIAL is unused, as
841 ph10 427 the restrictions on partial matching have been lifted. It remains for backwards
842 ph10 426 compatibility. */
843 nigel 77
844 ph10 836 #ifdef COMPILE_PCRE8
845     #define PCRE_MODE 0x0001 /* compiled in 8 bit mode */
846     #endif
847     #ifdef COMPILE_PCRE16
848     #define PCRE_MODE 0x0002 /* compiled in 16 bit mode */
849     #endif
850     #define PCRE_FIRSTSET 0x0010 /* first_char is set */
851     #define PCRE_FCH_CASELESS 0x0020 /* caseless first char */
852     #define PCRE_REQCHSET 0x0040 /* req_byte is set */
853     #define PCRE_RCH_CASELESS 0x0080 /* caseless requested char */
854     #define PCRE_STARTLINE 0x0100 /* start after \n for multiline */
855     #define PCRE_NOPARTIAL 0x0200 /* can't use partial with this regex */
856     #define PCRE_JCHANGED 0x0400 /* j option used in regex */
857     #define PCRE_HASCRORLF 0x0800 /* explicit \r or \n in pattern */
858     #define PCRE_HASTHEN 0x1000 /* pattern contains (*THEN) */
859 nigel 77
860 ph10 612 /* Flags for the "extra" block produced by pcre_study(). */
861 nigel 77
862 ph10 612 #define PCRE_STUDY_MAPPED 0x0001 /* a map of starting chars exists */
863     #define PCRE_STUDY_MINLEN 0x0002 /* a minimum length field exists */
864 nigel 77
865     /* Masks for identifying the public options that are permitted at compile
866     time, run time, or study time, respectively. */
867    
868 ph10 149 #define PCRE_NEWLINE_BITS (PCRE_NEWLINE_CR|PCRE_NEWLINE_LF|PCRE_NEWLINE_ANY| \
869     PCRE_NEWLINE_ANYCRLF)
870 nigel 93
871 ph10 389 #define PUBLIC_COMPILE_OPTIONS \
872 nigel 77 (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \
873     PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY|PCRE_UTF8| \
874 nigel 91 PCRE_NO_AUTO_CAPTURE|PCRE_NO_UTF8_CHECK|PCRE_AUTO_CALLOUT|PCRE_FIRSTLINE| \
875 ph10 336 PCRE_DUPNAMES|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE| \
876 ph10 576 PCRE_JAVASCRIPT_COMPAT|PCRE_UCP|PCRE_NO_START_OPTIMIZE)
877 nigel 77
878     #define PUBLIC_EXEC_OPTIONS \
879 ph10 442 (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NOTEMPTY_ATSTART| \
880     PCRE_NO_UTF8_CHECK|PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT|PCRE_NEWLINE_BITS| \
881     PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE|PCRE_NO_START_OPTIMIZE)
882 nigel 77
883     #define PUBLIC_DFA_EXEC_OPTIONS \
884 ph10 442 (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NOTEMPTY_ATSTART| \
885     PCRE_NO_UTF8_CHECK|PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT|PCRE_DFA_SHORTEST| \
886     PCRE_DFA_RESTART|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE| \
887     PCRE_NO_START_OPTIMIZE)
888 nigel 77
889 ph10 667 #define PUBLIC_STUDY_OPTIONS \
890     PCRE_STUDY_JIT_COMPILE
891 nigel 77
892 ph10 836 /* Magic number to provide a small check against being handed junk. */
893 nigel 77
894     #define MAGIC_NUMBER 0x50435245UL /* 'PCRE' */
895    
896 ph10 836 /* This variable is used to detect a loaded regular expression
897     in different endianness. */
898    
899     #define REVERSED_MAGIC_NUMBER 0x45524350UL /* 'ERCP' */
900    
901 nigel 77 /* Negative values for the firstchar and reqchar variables */
902    
903     #define REQ_UNSET (-2)
904     #define REQ_NONE (-1)
905    
906     /* The maximum remaining length of subject we are prepared to search for a
907     req_byte match. */
908    
909     #define REQ_BYTE_MAX 1000
910    
911 ph10 369 /* Miscellaneous definitions. The #ifndef is to pacify compiler warnings in
912 ph10 376 environments where these macros are defined elsewhere. Unfortunately, there
913     is no way to do the same for the typedef. */
914 nigel 77
915     typedef int BOOL;
916    
917 ph10 376 #ifndef FALSE
918 nigel 77 #define FALSE 0
919     #define TRUE 1
920 ph10 369 #endif
921 nigel 77
922 ph10 391 /* If PCRE is to support UTF-8 on EBCDIC platforms, we cannot use normal
923     character constants like '*' because the compiler would emit their EBCDIC code,
924 ph10 392 which is different from their ASCII/UTF-8 code. Instead we define macros for
925     the characters so that they always use the ASCII/UTF-8 code when UTF-8 support
926     is enabled. When UTF-8 support is not enabled, the definitions use character
927     literals. Both character and string versions of each character are needed, and
928 ph10 391 there are some longer strings as well.
929    
930 ph10 392 This means that, on EBCDIC platforms, the PCRE library can handle either
931 ph10 391 EBCDIC, or UTF-8, but not both. To support both in the same compiled library
932     would need different lookups depending on whether PCRE_UTF8 was set or not.
933     This would make it impossible to use characters in switch/case statements,
934 ph10 392 which would reduce performance. For a theoretical use (which nobody has asked
935     for) in a minority area (EBCDIC platforms), this is not sensible. Any
936     application that did need both could compile two versions of the library, using
937 ph10 391 macros to give the functions distinct names. */
938    
939 ph10 836 #ifndef SUPPORT_UTF
940 ph10 391
941     /* UTF-8 support is not enabled; use the platform-dependent character literals
942     so that PCRE works on both ASCII and EBCDIC platforms, in non-UTF-mode only. */
943    
944     #define CHAR_HT '\t'
945     #define CHAR_VT '\v'
946     #define CHAR_FF '\f'
947     #define CHAR_CR '\r'
948     #define CHAR_NL '\n'
949     #define CHAR_BS '\b'
950     #define CHAR_BEL '\a'
951     #ifdef EBCDIC
952     #define CHAR_ESC '\047'
953     #define CHAR_DEL '\007'
954     #else
955     #define CHAR_ESC '\033'
956     #define CHAR_DEL '\177'
957     #endif
958    
959     #define CHAR_SPACE ' '
960     #define CHAR_EXCLAMATION_MARK '!'
961     #define CHAR_QUOTATION_MARK '"'
962     #define CHAR_NUMBER_SIGN '#'
963     #define CHAR_DOLLAR_SIGN '$'
964     #define CHAR_PERCENT_SIGN '%'
965     #define CHAR_AMPERSAND '&'
966     #define CHAR_APOSTROPHE '\''
967     #define CHAR_LEFT_PARENTHESIS '('
968     #define CHAR_RIGHT_PARENTHESIS ')'
969     #define CHAR_ASTERISK '*'
970     #define CHAR_PLUS '+'
971     #define CHAR_COMMA ','
972     #define CHAR_MINUS '-'
973     #define CHAR_DOT '.'
974     #define CHAR_SLASH '/'
975     #define CHAR_0 '0'
976     #define CHAR_1 '1'
977     #define CHAR_2 '2'
978     #define CHAR_3 '3'
979     #define CHAR_4 '4'
980     #define CHAR_5 '5'
981     #define CHAR_6 '6'
982     #define CHAR_7 '7'
983     #define CHAR_8 '8'
984     #define CHAR_9 '9'
985     #define CHAR_COLON ':'
986     #define CHAR_SEMICOLON ';'
987     #define CHAR_LESS_THAN_SIGN '<'
988     #define CHAR_EQUALS_SIGN '='
989     #define CHAR_GREATER_THAN_SIGN '>'
990     #define CHAR_QUESTION_MARK '?'
991     #define CHAR_COMMERCIAL_AT '@'
992     #define CHAR_A 'A'
993     #define CHAR_B 'B'
994     #define CHAR_C 'C'
995     #define CHAR_D 'D'
996     #define CHAR_E 'E'
997     #define CHAR_F 'F'
998     #define CHAR_G 'G'
999     #define CHAR_H 'H'
1000     #define CHAR_I 'I'
1001     #define CHAR_J 'J'
1002     #define CHAR_K 'K'
1003     #define CHAR_L 'L'
1004     #define CHAR_M 'M'
1005     #define CHAR_N 'N'
1006     #define CHAR_O 'O'
1007     #define CHAR_P 'P'
1008     #define CHAR_Q 'Q'
1009     #define CHAR_R 'R'
1010     #define CHAR_S 'S'
1011     #define CHAR_T 'T'
1012     #define CHAR_U 'U'
1013     #define CHAR_V 'V'
1014     #define CHAR_W 'W'
1015     #define CHAR_X 'X'
1016     #define CHAR_Y 'Y'
1017     #define CHAR_Z 'Z'
1018     #define CHAR_LEFT_SQUARE_BRACKET '['
1019     #define CHAR_BACKSLASH '\\'
1020     #define CHAR_RIGHT_SQUARE_BRACKET ']'
1021     #define CHAR_CIRCUMFLEX_ACCENT '^'
1022     #define CHAR_UNDERSCORE '_'
1023     #define CHAR_GRAVE_ACCENT '`'
1024     #define CHAR_a 'a'
1025     #define CHAR_b 'b'
1026     #define CHAR_c 'c'
1027     #define CHAR_d 'd'
1028     #define CHAR_e 'e'
1029     #define CHAR_f 'f'
1030     #define CHAR_g 'g'
1031     #define CHAR_h 'h'
1032     #define CHAR_i 'i'
1033     #define CHAR_j 'j'
1034     #define CHAR_k 'k'
1035     #define CHAR_l 'l'
1036     #define CHAR_m 'm'
1037     #define CHAR_n 'n'
1038     #define CHAR_o 'o'
1039     #define CHAR_p 'p'
1040     #define CHAR_q 'q'
1041     #define CHAR_r 'r'
1042     #define CHAR_s 's'
1043     #define CHAR_t 't'
1044     #define CHAR_u 'u'
1045     #define CHAR_v 'v'
1046     #define CHAR_w 'w'
1047     #define CHAR_x 'x'
1048     #define CHAR_y 'y'
1049     #define CHAR_z 'z'
1050     #define CHAR_LEFT_CURLY_BRACKET '{'
1051     #define CHAR_VERTICAL_LINE '|'
1052     #define CHAR_RIGHT_CURLY_BRACKET '}'
1053     #define CHAR_TILDE '~'
1054    
1055     #define STR_HT "\t"
1056     #define STR_VT "\v"
1057     #define STR_FF "\f"
1058     #define STR_CR "\r"
1059     #define STR_NL "\n"
1060     #define STR_BS "\b"
1061     #define STR_BEL "\a"
1062     #ifdef EBCDIC
1063     #define STR_ESC "\047"
1064     #define STR_DEL "\007"
1065     #else
1066     #define STR_ESC "\033"
1067     #define STR_DEL "\177"
1068     #endif
1069    
1070     #define STR_SPACE " "
1071     #define STR_EXCLAMATION_MARK "!"
1072     #define STR_QUOTATION_MARK "\""
1073     #define STR_NUMBER_SIGN "#"
1074     #define STR_DOLLAR_SIGN "$"
1075     #define STR_PERCENT_SIGN "%"
1076     #define STR_AMPERSAND "&"
1077     #define STR_APOSTROPHE "'"
1078     #define STR_LEFT_PARENTHESIS "("
1079     #define STR_RIGHT_PARENTHESIS ")"
1080     #define STR_ASTERISK "*"
1081     #define STR_PLUS "+"
1082     #define STR_COMMA ","
1083     #define STR_MINUS "-"
1084     #define STR_DOT "."
1085     #define STR_SLASH "/"
1086     #define STR_0 "0"
1087     #define STR_1 "1"
1088     #define STR_2 "2"
1089     #define STR_3 "3"
1090     #define STR_4 "4"
1091     #define STR_5 "5"
1092     #define STR_6 "6"
1093     #define STR_7 "7"
1094     #define STR_8 "8"
1095     #define STR_9 "9"
1096     #define STR_COLON ":"
1097     #define STR_SEMICOLON ";"
1098     #define STR_LESS_THAN_SIGN "<"
1099     #define STR_EQUALS_SIGN "="
1100     #define STR_GREATER_THAN_SIGN ">"
1101     #define STR_QUESTION_MARK "?"
1102     #define STR_COMMERCIAL_AT "@"
1103     #define STR_A "A"
1104     #define STR_B "B"
1105     #define STR_C "C"
1106     #define STR_D "D"
1107     #define STR_E "E"
1108     #define STR_F "F"
1109     #define STR_G "G"
1110     #define STR_H "H"
1111     #define STR_I "I"
1112     #define STR_J "J"
1113     #define STR_K "K"
1114     #define STR_L "L"
1115     #define STR_M "M"
1116     #define STR_N "N"
1117     #define STR_O "O"
1118     #define STR_P "P"
1119     #define STR_Q "Q"
1120     #define STR_R "R"
1121     #define STR_S "S"
1122     #define STR_T "T"
1123     #define STR_U "U"
1124     #define STR_V "V"
1125     #define STR_W "W"
1126     #define STR_X "X"
1127     #define STR_Y "Y"
1128     #define STR_Z "Z"
1129     #define STR_LEFT_SQUARE_BRACKET "["
1130     #define STR_BACKSLASH "\\"
1131     #define STR_RIGHT_SQUARE_BRACKET "]"
1132     #define STR_CIRCUMFLEX_ACCENT "^"
1133     #define STR_UNDERSCORE "_"
1134     #define STR_GRAVE_ACCENT "`"
1135     #define STR_a "a"
1136     #define STR_b "b"
1137     #define STR_c "c"
1138     #define STR_d "d"
1139     #define STR_e "e"
1140     #define STR_f "f"
1141     #define STR_g "g"
1142     #define STR_h "h"
1143     #define STR_i "i"
1144     #define STR_j "j"
1145     #define STR_k "k"
1146     #define STR_l "l"
1147     #define STR_m "m"
1148     #define STR_n "n"
1149     #define STR_o "o"
1150     #define STR_p "p"
1151     #define STR_q "q"
1152     #define STR_r "r"
1153     #define STR_s "s"
1154     #define STR_t "t"
1155     #define STR_u "u"
1156     #define STR_v "v"
1157     #define STR_w "w"
1158     #define STR_x "x"
1159     #define STR_y "y"
1160     #define STR_z "z"
1161     #define STR_LEFT_CURLY_BRACKET "{"
1162     #define STR_VERTICAL_LINE "|"
1163     #define STR_RIGHT_CURLY_BRACKET "}"
1164     #define STR_TILDE "~"
1165    
1166     #define STRING_ACCEPT0 "ACCEPT\0"
1167     #define STRING_COMMIT0 "COMMIT\0"
1168     #define STRING_F0 "F\0"
1169     #define STRING_FAIL0 "FAIL\0"
1170 ph10 510 #define STRING_MARK0 "MARK\0"
1171 ph10 391 #define STRING_PRUNE0 "PRUNE\0"
1172     #define STRING_SKIP0 "SKIP\0"
1173     #define STRING_THEN "THEN"
1174    
1175     #define STRING_alpha0 "alpha\0"
1176     #define STRING_lower0 "lower\0"
1177     #define STRING_upper0 "upper\0"
1178     #define STRING_alnum0 "alnum\0"
1179     #define STRING_ascii0 "ascii\0"
1180     #define STRING_blank0 "blank\0"
1181     #define STRING_cntrl0 "cntrl\0"
1182     #define STRING_digit0 "digit\0"
1183     #define STRING_graph0 "graph\0"
1184     #define STRING_print0 "print\0"
1185     #define STRING_punct0 "punct\0"
1186     #define STRING_space0 "space\0"
1187     #define STRING_word0 "word\0"
1188     #define STRING_xdigit "xdigit"
1189    
1190     #define STRING_DEFINE "DEFINE"
1191    
1192 ph10 576 #define STRING_CR_RIGHTPAR "CR)"
1193     #define STRING_LF_RIGHTPAR "LF)"
1194     #define STRING_CRLF_RIGHTPAR "CRLF)"
1195     #define STRING_ANY_RIGHTPAR "ANY)"
1196     #define STRING_ANYCRLF_RIGHTPAR "ANYCRLF)"
1197     #define STRING_BSR_ANYCRLF_RIGHTPAR "BSR_ANYCRLF)"
1198     #define STRING_BSR_UNICODE_RIGHTPAR "BSR_UNICODE)"
1199 ph10 836 #ifdef COMPILE_PCRE8
1200     #define STRING_UTF_RIGHTPAR "UTF8)"
1201     #endif
1202     #ifdef COMPILE_PCRE16
1203     #define STRING_UTF_RIGHTPAR "UTF16)"
1204     #endif
1205 ph10 576 #define STRING_UCP_RIGHTPAR "UCP)"
1206     #define STRING_NO_START_OPT_RIGHTPAR "NO_START_OPT)"
1207 ph10 391
1208 ph10 836 #else /* SUPPORT_UTF */
1209 ph10 391
1210     /* UTF-8 support is enabled; always use UTF-8 (=ASCII) character codes. This
1211     works in both modes non-EBCDIC platforms, and on EBCDIC platforms in UTF-8 mode
1212     only. */
1213    
1214     #define CHAR_HT '\011'
1215     #define CHAR_VT '\013'
1216     #define CHAR_FF '\014'
1217     #define CHAR_CR '\015'
1218     #define CHAR_NL '\012'
1219     #define CHAR_BS '\010'
1220     #define CHAR_BEL '\007'
1221     #define CHAR_ESC '\033'
1222     #define CHAR_DEL '\177'
1223    
1224     #define CHAR_SPACE '\040'
1225     #define CHAR_EXCLAMATION_MARK '\041'
1226     #define CHAR_QUOTATION_MARK '\042'
1227     #define CHAR_NUMBER_SIGN '\043'
1228     #define CHAR_DOLLAR_SIGN '\044'
1229     #define CHAR_PERCENT_SIGN '\045'
1230     #define CHAR_AMPERSAND '\046'
1231     #define CHAR_APOSTROPHE '\047'
1232     #define CHAR_LEFT_PARENTHESIS '\050'
1233     #define CHAR_RIGHT_PARENTHESIS '\051'
1234     #define CHAR_ASTERISK '\052'
1235     #define CHAR_PLUS '\053'
1236     #define CHAR_COMMA '\054'
1237     #define CHAR_MINUS '\055'
1238     #define CHAR_DOT '\056'
1239     #define CHAR_SLASH '\057'
1240     #define CHAR_0 '\060'
1241     #define CHAR_1 '\061'
1242     #define CHAR_2 '\062'
1243     #define CHAR_3 '\063'
1244     #define CHAR_4 '\064'
1245     #define CHAR_5 '\065'
1246     #define CHAR_6 '\066'
1247     #define CHAR_7 '\067'
1248     #define CHAR_8 '\070'
1249     #define CHAR_9 '\071'
1250     #define CHAR_COLON '\072'
1251     #define CHAR_SEMICOLON '\073'
1252     #define CHAR_LESS_THAN_SIGN '\074'
1253     #define CHAR_EQUALS_SIGN '\075'
1254     #define CHAR_GREATER_THAN_SIGN '\076'
1255     #define CHAR_QUESTION_MARK '\077'
1256     #define CHAR_COMMERCIAL_AT '\100'
1257     #define CHAR_A '\101'
1258     #define CHAR_B '\102'
1259     #define CHAR_C '\103'
1260     #define CHAR_D '\104'
1261     #define CHAR_E '\105'
1262     #define CHAR_F '\106'
1263     #define CHAR_G '\107'
1264     #define CHAR_H '\110'
1265     #define CHAR_I '\111'
1266     #define CHAR_J '\112'
1267     #define CHAR_K '\113'
1268     #define CHAR_L '\114'
1269     #define CHAR_M '\115'
1270     #define CHAR_N '\116'
1271     #define CHAR_O '\117'
1272     #define CHAR_P '\120'
1273     #define CHAR_Q '\121'
1274     #define CHAR_R '\122'
1275     #define CHAR_S '\123'
1276     #define CHAR_T '\124'
1277     #define CHAR_U '\125'
1278     #define CHAR_V '\126'
1279     #define CHAR_W '\127'
1280     #define CHAR_X '\130'
1281     #define CHAR_Y '\131'
1282     #define CHAR_Z '\132'
1283     #define CHAR_LEFT_SQUARE_BRACKET '\133'
1284     #define CHAR_BACKSLASH '\134'
1285     #define CHAR_RIGHT_SQUARE_BRACKET '\135'
1286     #define CHAR_CIRCUMFLEX_ACCENT '\136'
1287     #define CHAR_UNDERSCORE '\137'
1288     #define CHAR_GRAVE_ACCENT '\140'
1289     #define CHAR_a '\141'
1290     #define CHAR_b '\142'
1291     #define CHAR_c '\143'
1292     #define CHAR_d '\144'
1293     #define CHAR_e '\145'
1294     #define CHAR_f '\146'
1295     #define CHAR_g '\147'
1296     #define CHAR_h '\150'
1297     #define CHAR_i '\151'
1298     #define CHAR_j '\152'
1299     #define CHAR_k '\153'
1300     #define CHAR_l '\154'
1301     #define CHAR_m '\155'
1302     #define CHAR_n '\156'
1303     #define CHAR_o '\157'
1304     #define CHAR_p '\160'
1305     #define CHAR_q '\161'
1306     #define CHAR_r '\162'
1307     #define CHAR_s '\163'
1308     #define CHAR_t '\164'
1309     #define CHAR_u '\165'
1310     #define CHAR_v '\166'
1311     #define CHAR_w '\167'
1312     #define CHAR_x '\170'
1313     #define CHAR_y '\171'
1314     #define CHAR_z '\172'
1315     #define CHAR_LEFT_CURLY_BRACKET '\173'
1316     #define CHAR_VERTICAL_LINE '\174'
1317     #define CHAR_RIGHT_CURLY_BRACKET '\175'
1318     #define CHAR_TILDE '\176'
1319    
1320     #define STR_HT "\011"
1321     #define STR_VT "\013"
1322     #define STR_FF "\014"
1323     #define STR_CR "\015"
1324     #define STR_NL "\012"
1325     #define STR_BS "\010"
1326     #define STR_BEL "\007"
1327     #define STR_ESC "\033"
1328     #define STR_DEL "\177"
1329    
1330     #define STR_SPACE "\040"
1331     #define STR_EXCLAMATION_MARK "\041"
1332     #define STR_QUOTATION_MARK "\042"
1333     #define STR_NUMBER_SIGN "\043"
1334     #define STR_DOLLAR_SIGN "\044"
1335     #define STR_PERCENT_SIGN "\045"
1336     #define STR_AMPERSAND "\046"
1337     #define STR_APOSTROPHE "\047"
1338     #define STR_LEFT_PARENTHESIS "\050"
1339     #define STR_RIGHT_PARENTHESIS "\051"
1340     #define STR_ASTERISK "\052"
1341     #define STR_PLUS "\053"
1342     #define STR_COMMA "\054"
1343     #define STR_MINUS "\055"
1344     #define STR_DOT "\056"
1345     #define STR_SLASH "\057"
1346     #define STR_0 "\060"
1347     #define STR_1 "\061"
1348     #define STR_2 "\062"
1349     #define STR_3 "\063"
1350     #define STR_4 "\064"
1351     #define STR_5 "\065"
1352     #define STR_6 "\066"
1353     #define STR_7 "\067"
1354     #define STR_8 "\070"
1355     #define STR_9 "\071"
1356     #define STR_COLON "\072"
1357     #define STR_SEMICOLON "\073"
1358     #define STR_LESS_THAN_SIGN "\074"
1359     #define STR_EQUALS_SIGN "\075"
1360     #define STR_GREATER_THAN_SIGN "\076"
1361     #define STR_QUESTION_MARK "\077"
1362     #define STR_COMMERCIAL_AT "\100"
1363     #define STR_A "\101"
1364     #define STR_B "\102"
1365     #define STR_C "\103"
1366     #define STR_D "\104"
1367     #define STR_E "\105"
1368     #define STR_F "\106"
1369     #define STR_G "\107"
1370     #define STR_H "\110"
1371     #define STR_I "\111"
1372     #define STR_J "\112"
1373     #define STR_K "\113"
1374     #define STR_L "\114"
1375     #define STR_M "\115"
1376     #define STR_N "\116"
1377     #define STR_O "\117"
1378     #define STR_P "\120"
1379     #define STR_Q "\121"
1380     #define STR_R "\122"
1381     #define STR_S "\123"
1382     #define STR_T "\124"
1383     #define STR_U "\125"
1384     #define STR_V "\126"
1385     #define STR_W "\127"
1386     #define STR_X "\130"
1387     #define STR_Y "\131"
1388     #define STR_Z "\132"
1389     #define STR_LEFT_SQUARE_BRACKET "\133"
1390     #define STR_BACKSLASH "\134"
1391     #define STR_RIGHT_SQUARE_BRACKET "\135"
1392     #define STR_CIRCUMFLEX_ACCENT "\136"
1393     #define STR_UNDERSCORE "\137"
1394     #define STR_GRAVE_ACCENT "\140"
1395     #define STR_a "\141"
1396     #define STR_b "\142"
1397     #define STR_c "\143"
1398     #define STR_d "\144"
1399     #define STR_e "\145"
1400     #define STR_f "\146"
1401     #define STR_g "\147"
1402     #define STR_h "\150"
1403     #define STR_i "\151"
1404     #define STR_j "\152"
1405     #define STR_k "\153"
1406     #define STR_l "\154"
1407     #define STR_m "\155"
1408     #define STR_n "\156"
1409     #define STR_o "\157"
1410     #define STR_p "\160"
1411     #define STR_q "\161"
1412     #define STR_r "\162"
1413     #define STR_s "\163"
1414     #define STR_t "\164"
1415     #define STR_u "\165"
1416     #define STR_v "\166"
1417     #define STR_w "\167"
1418     #define STR_x "\170"
1419     #define STR_y "\171"
1420     #define STR_z "\172"
1421     #define STR_LEFT_CURLY_BRACKET "\173"
1422     #define STR_VERTICAL_LINE "\174"
1423     #define STR_RIGHT_CURLY_BRACKET "\175"
1424     #define STR_TILDE "\176"
1425    
1426     #define STRING_ACCEPT0 STR_A STR_C STR_C STR_E STR_P STR_T "\0"
1427     #define STRING_COMMIT0 STR_C STR_O STR_M STR_M STR_I STR_T "\0"
1428     #define STRING_F0 STR_F "\0"
1429     #define STRING_FAIL0 STR_F STR_A STR_I STR_L "\0"
1430 ph10 510 #define STRING_MARK0 STR_M STR_A STR_R STR_K "\0"
1431 ph10 391 #define STRING_PRUNE0 STR_P STR_R STR_U STR_N STR_E "\0"
1432     #define STRING_SKIP0 STR_S STR_K STR_I STR_P "\0"
1433     #define STRING_THEN STR_T STR_H STR_E STR_N
1434    
1435     #define STRING_alpha0 STR_a STR_l STR_p STR_h STR_a "\0"
1436     #define STRING_lower0 STR_l STR_o STR_w STR_e STR_r "\0"
1437     #define STRING_upper0 STR_u STR_p STR_p STR_e STR_r "\0"
1438     #define STRING_alnum0 STR_a STR_l STR_n STR_u STR_m "\0"
1439     #define STRING_ascii0 STR_a STR_s STR_c STR_i STR_i "\0"
1440     #define STRING_blank0 STR_b STR_l STR_a STR_n STR_k "\0"
1441     #define STRING_cntrl0 STR_c STR_n STR_t STR_r STR_l "\0"
1442     #define STRING_digit0 STR_d STR_i STR_g STR_i STR_t "\0"
1443     #define STRING_graph0 STR_g STR_r STR_a STR_p STR_h "\0"
1444     #define STRING_print0 STR_p STR_r STR_i STR_n STR_t "\0"
1445     #define STRING_punct0 STR_p STR_u STR_n STR_c STR_t "\0"
1446     #define STRING_space0 STR_s STR_p STR_a STR_c STR_e "\0"
1447     #define STRING_word0 STR_w STR_o STR_r STR_d "\0"
1448     #define STRING_xdigit STR_x STR_d STR_i STR_g STR_i STR_t
1449    
1450     #define STRING_DEFINE STR_D STR_E STR_F STR_I STR_N STR_E
1451    
1452 ph10 576 #define STRING_CR_RIGHTPAR STR_C STR_R STR_RIGHT_PARENTHESIS
1453     #define STRING_LF_RIGHTPAR STR_L STR_F STR_RIGHT_PARENTHESIS
1454     #define STRING_CRLF_RIGHTPAR STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
1455     #define STRING_ANY_RIGHTPAR STR_A STR_N STR_Y STR_RIGHT_PARENTHESIS
1456     #define STRING_ANYCRLF_RIGHTPAR STR_A STR_N STR_Y STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
1457     #define STRING_BSR_ANYCRLF_RIGHTPAR STR_B STR_S STR_R STR_UNDERSCORE STR_A STR_N STR_Y STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
1458     #define STRING_BSR_UNICODE_RIGHTPAR STR_B STR_S STR_R STR_UNDERSCORE STR_U STR_N STR_I STR_C STR_O STR_D STR_E STR_RIGHT_PARENTHESIS
1459 ph10 836 #ifdef COMPILE_PCRE8
1460     #define STRING_UTF_RIGHTPAR STR_U STR_T STR_F STR_8 STR_RIGHT_PARENTHESIS
1461     #endif
1462     #ifdef COMPILE_PCRE16
1463     #define STRING_UTF_RIGHTPAR STR_U STR_T STR_F STR_1 STR_6 STR_RIGHT_PARENTHESIS
1464     #endif
1465 ph10 576 #define STRING_UCP_RIGHTPAR STR_U STR_C STR_P STR_RIGHT_PARENTHESIS
1466     #define STRING_NO_START_OPT_RIGHTPAR STR_N STR_O STR_UNDERSCORE STR_S STR_T STR_A STR_R STR_T STR_UNDERSCORE STR_O STR_P STR_T STR_RIGHT_PARENTHESIS
1467 ph10 391
1468 ph10 836 #endif /* SUPPORT_UTF */
1469 ph10 391
1470 nigel 93 /* Escape items that are just an encoding of a particular data value. */
1471 nigel 77
1472     #ifndef ESC_e
1473 ph10 391 #define ESC_e CHAR_ESC
1474 nigel 77 #endif
1475    
1476     #ifndef ESC_f
1477 ph10 391 #define ESC_f CHAR_FF
1478 nigel 77 #endif
1479    
1480     #ifndef ESC_n
1481 ph10 391 #define ESC_n CHAR_NL
1482 nigel 77 #endif
1483    
1484     #ifndef ESC_r
1485 ph10 391 #define ESC_r CHAR_CR
1486 nigel 77 #endif
1487    
1488     /* We can't officially use ESC_t because it is a POSIX reserved identifier
1489     (presumably because of all the others like size_t). */
1490    
1491     #ifndef ESC_tee
1492 ph10 391 #define ESC_tee CHAR_HT
1493 nigel 77 #endif
1494    
1495 nigel 87 /* Codes for different types of Unicode property */
1496    
1497     #define PT_ANY 0 /* Any property - matches all chars */
1498     #define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */
1499 ph10 517 #define PT_GC 2 /* Specified general characteristic (e.g. L) */
1500     #define PT_PC 3 /* Specified particular characteristic (e.g. Lu) */
1501 nigel 87 #define PT_SC 4 /* Script (e.g. Han) */
1502 ph10 517 #define PT_ALNUM 5 /* Alphanumeric - the union of L and N */
1503     #define PT_SPACE 6 /* Perl space - Z plus 9,10,12,13 */
1504     #define PT_PXSPACE 7 /* POSIX space - Z plus 9,10,11,12,13 */
1505     #define PT_WORD 8 /* Word - L plus N plus underscore */
1506 nigel 87
1507     /* Flag bits and data types for the extended class (OP_XCLASS) for classes that
1508 ph10 836 contain characters with values greater than 255. */
1509 nigel 87
1510     #define XCL_NOT 0x01 /* Flag: this is a negative class */
1511     #define XCL_MAP 0x02 /* Flag: a 32-byte map is present */
1512    
1513     #define XCL_END 0 /* Marks end of individual items */
1514     #define XCL_SINGLE 1 /* Single item (one multibyte char) follows */
1515     #define XCL_RANGE 2 /* A range (two multibyte chars) follows */
1516     #define XCL_PROP 3 /* Unicode property (2-byte property code follows) */
1517     #define XCL_NOTPROP 4 /* Unicode inverted property (ditto) */
1518    
1519 nigel 77 /* These are escaped items that aren't just an encoding of a particular data
1520     value such as \n. They must have non-zero values, as check_escape() returns
1521     their negation. Also, they must appear in the same order as in the opcode
1522 ph10 514 definitions below, up to ESC_z. There's a dummy for OP_ALLANY because it
1523     corresponds to "." in DOTALL mode rather than an escape sequence. It is also
1524 ph10 836 used for [^] in JavaScript compatibility mode, and for \C in non-utf mode. In
1525 ph10 754 non-DOTALL mode, "." behaves like \N.
1526 nigel 77
1527 ph10 518 The special values ESC_DU, ESC_du, etc. are used instead of ESC_D, ESC_d, etc.
1528     when PCRE_UCP is set, when replacement of \d etc by \p sequences is required.
1529     They must be contiguous, and remain in order so that the replacements can be
1530     looked up from a table.
1531    
1532 ph10 341 The final escape must be ESC_REF as subsequent values are used for
1533     backreferences (\1, \2, \3, etc). There are two tests in the code for an escape
1534     greater than ESC_b and less than ESC_Z to detect the types that may be
1535     repeated. These are the types that consume characters. If any new escapes are
1536     put in between that don't consume a character, that code will have to change.
1537     */
1538    
1539 ph10 172 enum { ESC_A = 1, ESC_G, ESC_K, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s,
1540 ph10 514 ESC_W, ESC_w, ESC_N, ESC_dum, ESC_C, ESC_P, ESC_p, ESC_R, ESC_H,
1541 ph10 535 ESC_h, ESC_V, ESC_v, ESC_X, ESC_Z, ESC_z,
1542 ph10 518 ESC_E, ESC_Q, ESC_g, ESC_k,
1543 ph10 535 ESC_DU, ESC_du, ESC_SU, ESC_su, ESC_WU, ESC_wu,
1544 ph10 341 ESC_REF };
1545 nigel 77
1546 ph10 210 /* Opcode table: Starting from 1 (i.e. after OP_END), the values up to
1547 nigel 77 OP_EOD must correspond in order to the list of escapes immediately above.
1548    
1549 nigel 93 *** NOTE NOTE NOTE *** Whenever this list is updated, the two macro definitions
1550 ph10 462 that follow must also be updated to match. There are also tables called
1551     "coptable" and "poptable" in pcre_dfa_exec.c that must be updated. */
1552 nigel 93
1553 nigel 77 enum {
1554     OP_END, /* 0 End of pattern */
1555    
1556     /* Values corresponding to backslashed metacharacters */
1557    
1558     OP_SOD, /* 1 Start of data: \A */
1559     OP_SOM, /* 2 Start of match (subject + offset): \G */
1560 ph10 172 OP_SET_SOM, /* 3 Set start of match (\K) */
1561 ph10 168 OP_NOT_WORD_BOUNDARY, /* 4 \B */
1562     OP_WORD_BOUNDARY, /* 5 \b */
1563     OP_NOT_DIGIT, /* 6 \D */
1564     OP_DIGIT, /* 7 \d */
1565     OP_NOT_WHITESPACE, /* 8 \S */
1566     OP_WHITESPACE, /* 9 \s */
1567     OP_NOT_WORDCHAR, /* 10 \W */
1568     OP_WORDCHAR, /* 11 \w */
1569 ph10 602
1570 ph10 514 OP_ANY, /* 12 Match any character except newline */
1571     OP_ALLANY, /* 13 Match any character */
1572 ph10 341 OP_ANYBYTE, /* 14 Match any byte (\C); different to OP_ANY for UTF-8 */
1573     OP_NOTPROP, /* 15 \P (not Unicode property) */
1574     OP_PROP, /* 16 \p (Unicode property) */
1575     OP_ANYNL, /* 17 \R (any newline sequence) */
1576     OP_NOT_HSPACE, /* 18 \H (not horizontal whitespace) */
1577     OP_HSPACE, /* 19 \h (horizontal whitespace) */
1578     OP_NOT_VSPACE, /* 20 \V (not vertical whitespace) */
1579     OP_VSPACE, /* 21 \v (vertical whitespace) */
1580     OP_EXTUNI, /* 22 \X (extended Unicode sequence */
1581     OP_EODN, /* 23 End of data or \n at end of data: \Z. */
1582     OP_EOD, /* 24 End of data: \z */
1583 nigel 77
1584 ph10 602 OP_CIRC, /* 25 Start of line - not multiline */
1585     OP_CIRCM, /* 26 Start of line - multiline */
1586     OP_DOLL, /* 27 End of line - not multiline */
1587     OP_DOLLM, /* 28 End of line - multiline */
1588     OP_CHAR, /* 29 Match one character, casefully */
1589     OP_CHARI, /* 30 Match one character, caselessly */
1590     OP_NOT, /* 31 Match one character, not the given one, casefully */
1591     OP_NOTI, /* 32 Match one character, not the given one, caselessly */
1592 nigel 77
1593 ph10 602 /* The following sets of 13 opcodes must always be kept in step because
1594     the offset from the first one is used to generate the others. */
1595 ph10 604
1596 ph10 602 /**** Single characters, caseful, must precede the caseless ones ****/
1597 nigel 77
1598 ph10 602 OP_STAR, /* 33 The maximizing and minimizing versions of */
1599     OP_MINSTAR, /* 34 these six opcodes must come in pairs, with */
1600     OP_PLUS, /* 35 the minimizing one second. */
1601     OP_MINPLUS, /* 36 */
1602     OP_QUERY, /* 37 */
1603     OP_MINQUERY, /* 38 */
1604 nigel 77
1605 ph10 602 OP_UPTO, /* 39 From 0 to n matches of one character, caseful*/
1606     OP_MINUPTO, /* 40 */
1607     OP_EXACT, /* 41 Exactly n matches */
1608 nigel 77
1609 ph10 602 OP_POSSTAR, /* 42 Possessified star, caseful */
1610     OP_POSPLUS, /* 43 Possessified plus, caseful */
1611     OP_POSQUERY, /* 44 Posesssified query, caseful */
1612     OP_POSUPTO, /* 45 Possessified upto, caseful */
1613 nigel 77
1614 ph10 602 /**** Single characters, caseless, must follow the caseful ones */
1615 ph10 604
1616 ph10 602 OP_STARI, /* 46 */
1617     OP_MINSTARI, /* 47 */
1618     OP_PLUSI, /* 48 */
1619     OP_MINPLUSI, /* 49 */
1620     OP_QUERYI, /* 50 */
1621     OP_MINQUERYI, /* 51 */
1622 nigel 93
1623 ph10 602 OP_UPTOI, /* 52 From 0 to n matches of one character, caseless */
1624     OP_MINUPTOI, /* 53 */
1625     OP_EXACTI, /* 54 */
1626 nigel 93
1627 ph10 602 OP_POSSTARI, /* 55 Possessified star, caseless */
1628     OP_POSPLUSI, /* 56 Possessified plus, caseless */
1629     OP_POSQUERYI, /* 57 Posesssified query, caseless */
1630     OP_POSUPTOI, /* 58 Possessified upto, caseless */
1631 nigel 93
1632 ph10 602 /**** The negated ones must follow the non-negated ones, and match them ****/
1633     /**** Negated single character, caseful; must precede the caseless ones ****/
1634 nigel 93
1635 ph10 602 OP_NOTSTAR, /* 59 The maximizing and minimizing versions of */
1636     OP_NOTMINSTAR, /* 60 these six opcodes must come in pairs, with */
1637     OP_NOTPLUS, /* 61 the minimizing one second. They must be in */
1638     OP_NOTMINPLUS, /* 62 exactly the same order as those above. */
1639     OP_NOTQUERY, /* 63 */
1640     OP_NOTMINQUERY, /* 64 */
1641 nigel 93
1642 ph10 602 OP_NOTUPTO, /* 65 From 0 to n matches, caseful */
1643     OP_NOTMINUPTO, /* 66 */
1644     OP_NOTEXACT, /* 67 Exactly n matches */
1645 nigel 93
1646 ph10 602 OP_NOTPOSSTAR, /* 68 Possessified versions, caseful */
1647     OP_NOTPOSPLUS, /* 69 */
1648     OP_NOTPOSQUERY, /* 70 */
1649     OP_NOTPOSUPTO, /* 71 */
1650 nigel 77
1651 ph10 602 /**** Negated single character, caseless; must follow the caseful ones ****/
1652 ph10 604
1653 ph10 602 OP_NOTSTARI, /* 72 */
1654     OP_NOTMINSTARI, /* 73 */
1655     OP_NOTPLUSI, /* 74 */
1656     OP_NOTMINPLUSI, /* 75 */
1657     OP_NOTQUERYI, /* 76 */
1658     OP_NOTMINQUERYI, /* 77 */
1659 nigel 77
1660 ph10 602 OP_NOTUPTOI, /* 78 From 0 to n matches, caseless */
1661     OP_NOTMINUPTOI, /* 79 */
1662     OP_NOTEXACTI, /* 80 Exactly n matches */
1663 nigel 77
1664 ph10 602 OP_NOTPOSSTARI, /* 81 Possessified versions, caseless */
1665     OP_NOTPOSPLUSI, /* 82 */
1666     OP_NOTPOSQUERYI, /* 83 */
1667     OP_NOTPOSUPTOI, /* 84 */
1668 nigel 77
1669 ph10 602 /**** Character types ****/
1670 ph10 604
1671 ph10 602 OP_TYPESTAR, /* 85 The maximizing and minimizing versions of */
1672     OP_TYPEMINSTAR, /* 86 these six opcodes must come in pairs, with */
1673     OP_TYPEPLUS, /* 87 the minimizing one second. These codes must */
1674     OP_TYPEMINPLUS, /* 88 be in exactly the same order as those above. */
1675     OP_TYPEQUERY, /* 89 */
1676     OP_TYPEMINQUERY, /* 90 */
1677    
1678     OP_TYPEUPTO, /* 91 From 0 to n matches */
1679     OP_TYPEMINUPTO, /* 92 */
1680     OP_TYPEEXACT, /* 93 Exactly n matches */
1681    
1682     OP_TYPEPOSSTAR, /* 94 Possessified versions */
1683     OP_TYPEPOSPLUS, /* 95 */
1684     OP_TYPEPOSQUERY, /* 96 */
1685     OP_TYPEPOSUPTO, /* 97 */
1686    
1687     /* These are used for character classes and back references; only the
1688 ph10 604 first six are the same as the sets above. */
1689 ph10 602
1690     OP_CRSTAR, /* 98 The maximizing and minimizing versions of */
1691     OP_CRMINSTAR, /* 99 all these opcodes must come in pairs, with */
1692     OP_CRPLUS, /* 100 the minimizing one second. These codes must */
1693     OP_CRMINPLUS, /* 101 be in exactly the same order as those above. */
1694     OP_CRQUERY, /* 102 */
1695     OP_CRMINQUERY, /* 103 */
1696    
1697     OP_CRRANGE, /* 104 These are different to the three sets above. */
1698     OP_CRMINRANGE, /* 105 */
1699    
1700     /* End of quantifier opcodes */
1701    
1702     OP_CLASS, /* 106 Match a character class, chars < 256 only */
1703     OP_NCLASS, /* 107 Same, but the bitmap was created from a negative
1704     class - the difference is relevant only when a
1705 ph10 836 character > 255 is encountered. */
1706     OP_XCLASS, /* 108 Extended class for handling > 255 chars within the
1707 ph10 602 class. This does both positive and negative. */
1708     OP_REF, /* 109 Match a back reference, casefully */
1709     OP_REFI, /* 110 Match a back reference, caselessly */
1710     OP_RECURSE, /* 111 Match a numbered subpattern (possibly recursive) */
1711     OP_CALLOUT, /* 112 Call out to external function if provided */
1712    
1713     OP_ALT, /* 113 Start of alternation */
1714     OP_KET, /* 114 End of group that doesn't have an unbounded repeat */
1715     OP_KETRMAX, /* 115 These two must remain together and in this */
1716     OP_KETRMIN, /* 116 order. They are for groups the repeat for ever. */
1717 ph10 604 OP_KETRPOS, /* 117 Possessive unlimited repeat. */
1718 ph10 602
1719 ph10 613 /* The assertions must come before BRA, CBRA, ONCE, and COND, and the four
1720     asserts must remain in order. */
1721 nigel 77
1722 ph10 637 OP_REVERSE, /* 118 Move pointer back - used in lookbehind assertions */
1723     OP_ASSERT, /* 119 Positive lookahead */
1724     OP_ASSERT_NOT, /* 120 Negative lookahead */
1725     OP_ASSERTBACK, /* 121 Positive lookbehind */
1726     OP_ASSERTBACK_NOT, /* 122 Negative lookbehind */
1727 nigel 77
1728 ph10 723 /* ONCE, ONCE_NC, BRA, BRAPOS, CBRA, CBRAPOS, and COND must come immediately
1729     after the assertions, with ONCE first, as there's a test for >= ONCE for a
1730     subpattern that isn't an assertion. The POS versions must immediately follow
1731     the non-POS versions in each case. */
1732 nigel 77
1733 ph10 723 OP_ONCE, /* 123 Atomic group, contains captures */
1734 ph10 733 OP_ONCE_NC, /* 124 Atomic group containing no captures */
1735 ph10 723 OP_BRA, /* 125 Start of non-capturing bracket */
1736     OP_BRAPOS, /* 126 Ditto, with unlimited, possessive repeat */
1737     OP_CBRA, /* 127 Start of capturing bracket */
1738     OP_CBRAPOS, /* 128 Ditto, with unlimited, possessive repeat */
1739     OP_COND, /* 129 Conditional group */
1740 nigel 77
1741 ph10 604 /* These five must follow the previous five, in the same order. There's a
1742 nigel 93 check for >= SBRA to distinguish the two sets. */
1743 nigel 77
1744 ph10 723 OP_SBRA, /* 130 Start of non-capturing bracket, check empty */
1745     OP_SBRAPOS, /* 131 Ditto, with unlimited, possessive repeat */
1746     OP_SCBRA, /* 132 Start of capturing bracket, check empty */
1747     OP_SCBRAPOS, /* 133 Ditto, with unlimited, possessive repeat */
1748     OP_SCOND, /* 134 Conditional group, check empty */
1749 nigel 77
1750 ph10 459 /* The next two pairs must (respectively) be kept together. */
1751 ph10 461
1752 ph10 723 OP_CREF, /* 135 Used to hold a capture number as condition */
1753     OP_NCREF, /* 136 Same, but generated by a name reference*/
1754     OP_RREF, /* 137 Used to hold a recursion number as condition */
1755     OP_NRREF, /* 138 Same, but generated by a name reference*/
1756     OP_DEF, /* 139 The DEFINE condition */
1757 nigel 93
1758 ph10 723 OP_BRAZERO, /* 140 These two must remain together and in this */
1759     OP_BRAMINZERO, /* 141 order. */
1760     OP_BRAPOSZERO, /* 142 */
1761 ph10 210
1762     /* These are backtracking control verbs */
1763    
1764 ph10 723 OP_MARK, /* 143 always has an argument */
1765     OP_PRUNE, /* 144 */
1766     OP_PRUNE_ARG, /* 145 same, but with argument */
1767     OP_SKIP, /* 146 */
1768     OP_SKIP_ARG, /* 147 same, but with argument */
1769     OP_THEN, /* 148 */
1770     OP_THEN_ARG, /* 149 same, but with argument */
1771     OP_COMMIT, /* 150 */
1772 ph10 210
1773     /* These are forced failure and success verbs */
1774    
1775 ph10 723 OP_FAIL, /* 151 */
1776     OP_ACCEPT, /* 152 */
1777     OP_ASSERT_ACCEPT, /* 153 Used inside assertions */
1778     OP_CLOSE, /* 154 Used before OP_ACCEPT to close open captures */
1779 ph10 345
1780 ph10 335 /* This is used to skip a subpattern with a {0} quantifier */
1781 ph10 345
1782 ph10 723 OP_SKIPZERO, /* 155 */
1783 ph10 498
1784     /* This is not an opcode, but is used to check that tables indexed by opcode
1785     are the correct length, in order to catch updating errors - there have been
1786     some in the past. */
1787    
1788     OP_TABLE_LENGTH
1789 nigel 77 };
1790    
1791 ph10 462 /* *** NOTE NOTE NOTE *** Whenever the list above is updated, the two macro
1792     definitions that follow must also be updated to match. There are also tables
1793 ph10 510 called "coptable" and "poptable" in pcre_dfa_exec.c that must be updated. */
1794 nigel 77
1795 ph10 462
1796 nigel 77 /* This macro defines textual names for all the opcodes. These are used only
1797 ph10 602 for debugging, and some of them are only partial names. The macro is referenced
1798 ph10 604 only in pcre_printint.c, which fills out the full names in many cases (and in
1799 ph10 602 some cases doesn't actually use these names at all). */
1800 nigel 77
1801     #define OP_NAME_LIST \
1802 ph10 168 "End", "\\A", "\\G", "\\K", "\\B", "\\b", "\\D", "\\d", \
1803 ph10 341 "\\S", "\\s", "\\W", "\\w", "Any", "AllAny", "Anybyte", \
1804 ph10 178 "notprop", "prop", "\\R", "\\H", "\\h", "\\V", "\\v", \
1805     "extuni", "\\Z", "\\z", \
1806 ph10 602 "^", "^", "$", "$", "char", "chari", "not", "noti", \
1807     "*", "*?", "+", "+?", "?", "??", \
1808     "{", "{", "{", \
1809 nigel 93 "*+","++", "?+", "{", \
1810 ph10 602 "*", "*?", "+", "+?", "?", "??", \
1811     "{", "{", "{", \
1812 nigel 93 "*+","++", "?+", "{", \
1813 ph10 602 "*", "*?", "+", "+?", "?", "??", \
1814     "{", "{", "{", \
1815     "*+","++", "?+", "{", \
1816     "*", "*?", "+", "+?", "?", "??", \
1817     "{", "{", "{", \
1818     "*+","++", "?+", "{", \
1819 nigel 77 "*", "*?", "+", "+?", "?", "??", "{", "{", "{", \
1820 nigel 93 "*+","++", "?+", "{", \
1821 nigel 77 "*", "*?", "+", "+?", "?", "??", "{", "{", \
1822 ph10 602 "class", "nclass", "xclass", "Ref", "Refi", \
1823     "Recurse", "Callout", \
1824 ph10 604 "Alt", "Ket", "KetRmax", "KetRmin", "KetRpos", \
1825 ph10 637 "Reverse", "Assert", "Assert not", "AssertB", "AssertB not", \
1826 ph10 723 "Once", "Once_NC", \
1827 ph10 604 "Bra", "BraPos", "CBra", "CBraPos", \
1828     "Cond", \
1829     "SBra", "SBraPos", "SCBra", "SCBraPos", \
1830     "SCond", \
1831 ph10 459 "Cond ref", "Cond nref", "Cond rec", "Cond nrec", "Cond def", \
1832 ph10 604 "Brazero", "Braminzero", "Braposzero", \
1833 ph10 510 "*MARK", "*PRUNE", "*PRUNE", "*SKIP", "*SKIP", \
1834 ph10 613 "*THEN", "*THEN", "*COMMIT", "*FAIL", \
1835     "*ACCEPT", "*ASSERT_ACCEPT", \
1836 ph10 447 "Close", "Skip zero"
1837 nigel 77
1838    
1839     /* This macro defines the length of fixed length operations in the compiled
1840     regex. The lengths are used when searching for specific things, and also in the
1841     debugging printing of a compiled regex. We use a macro so that it can be
1842     defined close to the definitions of the opcodes themselves.
1843    
1844     As things have been extended, some of these are no longer fixed lenths, but are
1845     minima instead. For example, the length of a single-character repeat may vary
1846     in UTF-8 mode. The code that uses this table must know about such things. */
1847    
1848     #define OP_LENGTHS \
1849     1, /* End */ \
1850 ph10 168 1, 1, 1, 1, 1, /* \A, \G, \K, \B, \b */ \
1851     1, 1, 1, 1, 1, 1, /* \D, \d, \S, \s, \W, \w */ \
1852 ph10 341 1, 1, 1, /* Any, AllAny, Anybyte */ \
1853 ph10 498 3, 3, /* \P, \p */ \
1854 ph10 178 1, 1, 1, 1, 1, /* \R, \H, \h, \V, \v */ \
1855 ph10 498 1, /* \X */ \
1856 ph10 602 1, 1, 1, 1, 1, 1, /* \Z, \z, ^, ^M, $, $M */ \
1857 nigel 77 2, /* Char - the minimum length */ \
1858 ph10 602 2, /* Chari - the minimum length */ \
1859 nigel 77 2, /* not */ \
1860 ph10 602 2, /* noti */ \
1861     /* Positive single-char repeats ** These are */ \
1862     2, 2, 2, 2, 2, 2, /* *, *?, +, +?, ?, ?? ** minima in */ \
1863 ph10 836 2+IMM2_SIZE, 2+IMM2_SIZE, /* upto, minupto ** mode */ \
1864     2+IMM2_SIZE, /* exact */ \
1865     2, 2, 2, 2+IMM2_SIZE, /* *+, ++, ?+, upto+ */ \
1866 ph10 602 2, 2, 2, 2, 2, 2, /* *I, *?I, +I, +?I, ?I, ??I ** UTF-8 */ \
1867 ph10 836 2+IMM2_SIZE, 2+IMM2_SIZE, /* upto I, minupto I */ \
1868     2+IMM2_SIZE, /* exact I */ \
1869     2, 2, 2, 2+IMM2_SIZE, /* *+I, ++I, ?+I, upto+I */ \
1870 nigel 77 /* Negative single-char repeats - only for chars < 256 */ \
1871     2, 2, 2, 2, 2, 2, /* NOT *, *?, +, +?, ?, ?? */ \
1872 ph10 836 2+IMM2_SIZE, 2+IMM2_SIZE, /* NOT upto, minupto */ \
1873     2+IMM2_SIZE, /* NOT exact */ \
1874     2, 2, 2, 2+IMM2_SIZE, /* Possessive NOT *, +, ?, upto */ \
1875 ph10 602 2, 2, 2, 2, 2, 2, /* NOT *I, *?I, +I, +?I, ?I, ??I */ \
1876 ph10 836 2+IMM2_SIZE, 2+IMM2_SIZE, /* NOT upto I, minupto I */ \
1877     2+IMM2_SIZE, /* NOT exact I */ \
1878     2, 2, 2, 2+IMM2_SIZE, /* Possessive NOT *I, +I, ?I, upto I */ \
1879 nigel 77 /* Positive type repeats */ \
1880     2, 2, 2, 2, 2, 2, /* Type *, *?, +, +?, ?, ?? */ \
1881 ph10 836 2+IMM2_SIZE, 2+IMM2_SIZE, /* Type upto, minupto */ \
1882     2+IMM2_SIZE, /* Type exact */ \
1883     2, 2, 2, 2+IMM2_SIZE, /* Possessive *+, ++, ?+, upto+ */ \
1884 nigel 77 /* Character class & ref repeats */ \
1885     1, 1, 1, 1, 1, 1, /* *, *?, +, +?, ?, ?? */ \
1886 ph10 836 1+2*IMM2_SIZE, 1+2*IMM2_SIZE, /* CRRANGE, CRMINRANGE */ \
1887     1+(32/sizeof(pcre_uchar)), /* CLASS */ \
1888     1+(32/sizeof(pcre_uchar)), /* NCLASS */ \
1889 nigel 77 0, /* XCLASS - variable length */ \
1890 ph10 836 1+IMM2_SIZE, /* REF */ \
1891     1+IMM2_SIZE, /* REFI */ \
1892 nigel 77 1+LINK_SIZE, /* RECURSE */ \
1893     2+2*LINK_SIZE, /* CALLOUT */ \
1894     1+LINK_SIZE, /* Alt */ \
1895     1+LINK_SIZE, /* Ket */ \
1896     1+LINK_SIZE, /* KetRmax */ \
1897     1+LINK_SIZE, /* KetRmin */ \
1898 ph10 604 1+LINK_SIZE, /* KetRpos */ \
1899 ph10 637 1+LINK_SIZE, /* Reverse */ \
1900 nigel 77 1+LINK_SIZE, /* Assert */ \
1901     1+LINK_SIZE, /* Assert not */ \
1902     1+LINK_SIZE, /* Assert behind */ \
1903     1+LINK_SIZE, /* Assert behind not */ \
1904 nigel 93 1+LINK_SIZE, /* ONCE */ \
1905 ph10 723 1+LINK_SIZE, /* ONCE_NC */ \
1906 nigel 93 1+LINK_SIZE, /* BRA */ \
1907 ph10 604 1+LINK_SIZE, /* BRAPOS */ \
1908 ph10 836 1+LINK_SIZE+IMM2_SIZE, /* CBRA */ \
1909     1+LINK_SIZE+IMM2_SIZE, /* CBRAPOS */ \
1910 nigel 77 1+LINK_SIZE, /* COND */ \
1911 nigel 93 1+LINK_SIZE, /* SBRA */ \
1912 ph10 604 1+LINK_SIZE, /* SBRAPOS */ \
1913 ph10 836 1+LINK_SIZE+IMM2_SIZE, /* SCBRA */ \
1914     1+LINK_SIZE+IMM2_SIZE, /* SCBRAPOS */ \
1915 nigel 93 1+LINK_SIZE, /* SCOND */ \
1916 ph10 836 1+IMM2_SIZE, 1+IMM2_SIZE, /* CREF, NCREF */ \
1917     1+IMM2_SIZE, 1+IMM2_SIZE, /* RREF, NRREF */ \
1918 nigel 93 1, /* DEF */ \
1919 ph10 604 1, 1, 1, /* BRAZERO, BRAMINZERO, BRAPOSZERO */ \
1920 ph10 550 3, 1, 3, /* MARK, PRUNE, PRUNE_ARG */ \
1921     1, 3, /* SKIP, SKIP_ARG */ \
1922 ph10 716 1, 3, /* THEN, THEN_ARG */ \
1923 ph10 613 1, 1, 1, 1, /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT */ \
1924 ph10 836 1+IMM2_SIZE, 1 /* CLOSE, SKIPZERO */
1925 nigel 77
1926 ph10 459 /* A magic value for OP_RREF and OP_NRREF to indicate the "any recursion"
1927     condition. */
1928 nigel 77
1929 nigel 93 #define RREF_ANY 0xffff
1930 nigel 77
1931 ph10 499 /* Compile time error code numbers. They are given names so that they can more
1932 ph10 507 easily be tracked. When a new number is added, the table called eint in
1933 ph10 499 pcreposix.c must be updated. */
1934 nigel 77
1935     enum { ERR0, ERR1, ERR2, ERR3, ERR4, ERR5, ERR6, ERR7, ERR8, ERR9,
1936     ERR10, ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19,
1937     ERR20, ERR21, ERR22, ERR23, ERR24, ERR25, ERR26, ERR27, ERR28, ERR29,
1938     ERR30, ERR31, ERR32, ERR33, ERR34, ERR35, ERR36, ERR37, ERR38, ERR39,
1939 nigel 91 ERR40, ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47, ERR48, ERR49,
1940 ph10 210 ERR50, ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57, ERR58, ERR59,
1941 ph10 629 ERR60, ERR61, ERR62, ERR63, ERR64, ERR65, ERR66, ERR67, ERR68, ERR69,
1942 ph10 848 ERR70, ERR71, ERR72, ERR73, ERR74, ERRCOUNT };
1943 nigel 77
1944     /* The real format of the start of the pcre block; the index of names and the
1945     code vector run on as long as necessary after the end. We store an explicit
1946     offset to the name table so that if a regex is compiled on one host, saved, and
1947     then run on another where the size of pointers is different, all might still
1948     be well. For the case of compiled-on-4 and run-on-8, we include an extra
1949     pointer that is always NULL. For future-proofing, a few dummy fields were
1950     originally included - even though you can never get this planning right - but
1951     there is only one left now.
1952    
1953     NOTE NOTE NOTE:
1954     Because people can now save and re-use compiled patterns, any additions to this
1955     structure should be made at the end, and something earlier (e.g. a new
1956     flag in the options or one of the dummy fields) should indicate that the new
1957     fields are present. Currently PCRE always sets the dummy fields to zero.
1958 ph10 455 NOTE NOTE NOTE
1959 nigel 77 */
1960    
1961 zherczeg 852 #ifdef COMPILE_PCRE8
1962     #define REAL_PCRE real_pcre
1963     #else
1964     #define REAL_PCRE real_pcre16
1965     #endif
1966    
1967     typedef struct REAL_PCRE {
1968 nigel 77 pcre_uint32 magic_number;
1969     pcre_uint32 size; /* Total that was malloced */
1970 ph10 230 pcre_uint32 options; /* Public options */
1971     pcre_uint16 flags; /* Private flags */
1972     pcre_uint16 dummy1; /* For future use */
1973 nigel 77 pcre_uint16 top_bracket;
1974     pcre_uint16 top_backref;
1975 ph10 836 pcre_uint16 first_char; /* Starting character */
1976     pcre_uint16 req_char; /* This character must be seen */
1977 nigel 77 pcre_uint16 name_table_offset; /* Offset to name table that follows */
1978     pcre_uint16 name_entry_size; /* Size of any name items */
1979     pcre_uint16 name_count; /* Number of name items */
1980     pcre_uint16 ref_count; /* Reference count */
1981    
1982 ph10 836 const pcre_uint8 *tables; /* Pointer to tables or NULL for std */
1983     const pcre_uint8 *nullpad; /* NULL padding */
1984 zherczeg 852 } REAL_PCRE;
1985 nigel 77
1986     /* The format of the block used to store data from pcre_study(). The same
1987     remark (see NOTE above) about extending this structure applies. */
1988    
1989     typedef struct pcre_study_data {
1990     pcre_uint32 size; /* Total that was malloced */
1991 ph10 455 pcre_uint32 flags; /* Private flags */
1992 ph10 836 pcre_uint8 start_bits[32]; /* Starting char bits */
1993 ph10 459 pcre_uint32 minlength; /* Minimum subject length */
1994 nigel 77 } pcre_study_data;
1995    
1996 ph10 459 /* Structure for building a chain of open capturing subpatterns during
1997     compiling, so that instructions to close them can be compiled when (*ACCEPT) is
1998 ph10 488 encountered. This is also used to identify subpatterns that contain recursive
1999     back references to themselves, so that they can be made atomic. */
2000 ph10 447
2001     typedef struct open_capitem {
2002     struct open_capitem *next; /* Chain link */
2003     pcre_uint16 number; /* Capture number */
2004 ph10 488 pcre_uint16 flag; /* Set TRUE if recursive back ref */
2005 ph10 459 } open_capitem;
2006 ph10 447
2007 nigel 77 /* Structure for passing "static" information around between the functions
2008     doing the compiling, so that they are thread-safe. */
2009    
2010     typedef struct compile_data {
2011 ph10 836 const pcre_uint8 *lcc; /* Points to lower casing table */
2012     const pcre_uint8 *fcc; /* Points to case-flipping table */
2013     const pcre_uint8 *cbits; /* Points to character type table */
2014     const pcre_uint8 *ctypes; /* Points to table of type maps */
2015     const pcre_uchar *start_workspace;/* The start of working space */
2016     const pcre_uchar *start_code; /* The start of the compiled code */
2017     const pcre_uchar *start_pattern; /* The start of the pattern */
2018     const pcre_uchar *end_pattern; /* The end of the pattern */
2019     open_capitem *open_caps; /* Chain of open capture items */
2020     pcre_uchar *hwm; /* High watermark of workspace */
2021     pcre_uchar *name_table; /* The name/number table */
2022     int names_found; /* Number of entries so far */
2023     int name_entry_size; /* Size of each entry */
2024     int workspace_size; /* Size of workspace */
2025     int bracount; /* Count of capturing parens as we compile */
2026     int final_bracount; /* Saved value after first pass */
2027     int top_backref; /* Maximum back reference */
2028     unsigned int backref_map; /* Bitmap of low back refs */
2029     int assert_depth; /* Depth of nested assertions */
2030     int external_options; /* External (initial) options */
2031     int external_flags; /* External flag bits to be set */
2032     int req_varyopt; /* "After variable item" flag for reqbyte */
2033     BOOL had_accept; /* (*ACCEPT) encountered */
2034     BOOL check_lookbehind; /* Lookbehinds need later checking */
2035     int nltype; /* Newline type */
2036     int nllen; /* Newline string length */
2037     pcre_uchar nl[4]; /* Newline string when fixed length */
2038 nigel 77 } compile_data;
2039    
2040     /* Structure for maintaining a chain of pointers to the currently incomplete
2041 ph10 642 branches, for testing for left recursion while compiling. */
2042 nigel 77
2043     typedef struct branch_chain {
2044     struct branch_chain *outer;
2045 ph10 836 pcre_uchar *current_branch;
2046 nigel 77 } branch_chain;
2047    
2048     /* Structure for items in a linked list that represents an explicit recursive
2049 ph10 642 call within the pattern; used by pcre_exec(). */
2050 nigel 77
2051     typedef struct recursion_info {
2052     struct recursion_info *prevrec; /* Previous recursion record (or NULL) */
2053 ph10 618 int group_num; /* Number of group that was called */
2054     int *offset_save; /* Pointer to start of saved offsets */
2055     int saved_max; /* Number of saved offsets */
2056 ph10 836 PCRE_PUCHAR subject_position; /* Position at start of recursion */
2057 nigel 77 } recursion_info;
2058    
2059 ph10 642 /* A similar structure for pcre_dfa_exec(). */
2060    
2061     typedef struct dfa_recursion_info {
2062     struct dfa_recursion_info *prevrec;
2063     int group_num;
2064 ph10 836 PCRE_PUCHAR subject_position;
2065 ph10 642 } dfa_recursion_info;
2066    
2067 nigel 93 /* Structure for building a chain of data for holding the values of the subject
2068     pointer at the start of each subpattern, so as to detect when an empty string
2069 ph10 654 has been matched by a subpattern - to break infinite loops; used by
2070 ph10 642 pcre_exec(). */
2071 nigel 93
2072     typedef struct eptrblock {
2073     struct eptrblock *epb_prev;
2074 ph10 836 PCRE_PUCHAR epb_saved_eptr;
2075 nigel 93 } eptrblock;
2076    
2077    
2078 nigel 77 /* Structure for passing "static" information around between the functions
2079     doing traditional NFA matching, so that they are thread-safe. */
2080    
2081     typedef struct match_data {
2082 nigel 87 unsigned long int match_call_count; /* As it says */
2083     unsigned long int match_limit; /* As it says */
2084     unsigned long int match_limit_recursion; /* As it says */
2085 ph10 836 int *offset_vector; /* Offset vector */
2086     int offset_end; /* One past the end */
2087     int offset_max; /* The maximum usable for return data */
2088     int nltype; /* Newline type */
2089     int nllen; /* Newline string length */
2090     int name_count; /* Number of names in name table */
2091     int name_entry_size; /* Size of entry in names table */
2092     pcre_uchar *name_table; /* Table of names */
2093     pcre_uchar nl[4]; /* Newline string when fixed */
2094     const pcre_uint8 *lcc; /* Points to lower casing table */
2095     const pcre_uint8 *fcc; /* Points to case-flipping table */
2096     const pcre_uint8 *ctypes; /* Points to table of type maps */
2097     BOOL offset_overflow; /* Set if too many extractions */
2098     BOOL notbol; /* NOTBOL flag */
2099     BOOL noteol; /* NOTEOL flag */
2100     BOOL utf; /* UTF-8 / UTF-16 flag */
2101     BOOL jscript_compat; /* JAVASCRIPT_COMPAT flag */
2102     BOOL use_ucp; /* PCRE_UCP flag */
2103     BOOL endonly; /* Dollar not before final \n */
2104     BOOL notempty; /* Empty string match not wanted */
2105     BOOL notempty_atstart; /* Empty string match at start not wanted */
2106     BOOL hitend; /* Hit the end of the subject at some point */
2107     BOOL bsr_anycrlf; /* \R is just any CRLF, not full Unicode */
2108     BOOL hasthen; /* Pattern contains (*THEN) */
2109     BOOL ignore_skip_arg; /* For re-run when SKIP name not found */
2110     const pcre_uchar *start_code; /* For use when recursing */
2111     PCRE_PUCHAR start_subject; /* Start of the subject string */
2112     PCRE_PUCHAR end_subject; /* End of the subject string */
2113     PCRE_PUCHAR start_match_ptr; /* Start of matched string */
2114     PCRE_PUCHAR end_match_ptr; /* Subject position at end match */
2115     PCRE_PUCHAR start_used_ptr; /* Earliest consulted character */
2116     int partial; /* PARTIAL options */
2117     int end_offset_top; /* Highwater mark at end of match */
2118     int capture_last; /* Most recent capture number */
2119     int start_offset; /* The start offset value */
2120     int match_function_type; /* Set for certain special calls of MATCH() */
2121     eptrblock *eptrchain; /* Chain of eptrblocks for tail recursions */
2122     int eptrn; /* Next free eptrblock */
2123     recursion_info *recursive; /* Linked list of recursion data */
2124     void *callout_data; /* To pass back to callouts */
2125     const pcre_uchar *mark; /* Mark pointer to pass back on success */
2126     const pcre_uchar *nomatch_mark;/* Mark pointer to pass back on failure */
2127     const pcre_uchar *once_target; /* Where to back up to for atomic groups */
2128 nigel 77 } match_data;
2129    
2130     /* A similar structure is used for the same purpose by the DFA matching
2131     functions. */
2132    
2133     typedef struct dfa_match_data {
2134 ph10 836 const pcre_uchar *start_code; /* Start of the compiled pattern */
2135     const pcre_uchar *start_subject ; /* Start of the subject string */
2136     const pcre_uchar *end_subject; /* End of subject string */
2137     const pcre_uchar *start_used_ptr; /* Earliest consulted character */
2138     const pcre_uint8 *tables; /* Character tables */
2139     int start_offset; /* The start offset value */
2140     int moptions; /* Match options */
2141     int poptions; /* Pattern options */
2142     int nltype; /* Newline type */
2143     int nllen; /* Newline string length */
2144     pcre_uchar nl[4]; /* Newline string when fixed */
2145     void *callout_data; /* To pass back to callouts */
2146     dfa_recursion_info *recursive; /* Linked list of recursion data */
2147 nigel 77 } dfa_match_data;
2148    
2149     /* Bit definitions for entries in the pcre_ctypes table. */
2150    
2151     #define ctype_space 0x01
2152     #define ctype_letter 0x02
2153     #define ctype_digit 0x04
2154     #define ctype_xdigit 0x08
2155 ph10 274 #define ctype_word 0x10 /* alphanumeric or '_' */
2156 nigel 77 #define ctype_meta 0x80 /* regexp meta char or zero (end pattern) */
2157    
2158     /* Offsets for the bitmap tables in pcre_cbits. Each table contains a set
2159     of bits for a class map. Some classes are built by combining these tables. */
2160    
2161     #define cbit_space 0 /* [:space:] or \s */
2162     #define cbit_xdigit 32 /* [:xdigit:] */
2163     #define cbit_digit 64 /* [:digit:] or \d */
2164     #define cbit_upper 96 /* [:upper:] */
2165     #define cbit_lower 128 /* [:lower:] */
2166     #define cbit_word 160 /* [:word:] or \w */
2167     #define cbit_graph 192 /* [:graph:] */
2168     #define cbit_print 224 /* [:print:] */
2169     #define cbit_punct 256 /* [:punct:] */
2170     #define cbit_cntrl 288 /* [:cntrl:] */
2171     #define cbit_length 320 /* Length of the cbits table */
2172    
2173     /* Offsets of the various tables from the base tables pointer, and
2174     total length. */
2175    
2176     #define lcc_offset 0
2177     #define fcc_offset 256
2178     #define cbits_offset 512
2179     #define ctypes_offset (cbits_offset + cbit_length)
2180     #define tables_length (ctypes_offset + 256)
2181    
2182 ph10 836 /* Internal function prefix */
2183    
2184     #ifdef COMPILE_PCRE8
2185     #define PUBL(name) pcre_##name
2186     #define PRIV(name) _pcre_##name
2187     #else
2188     #ifdef COMPILE_PCRE16
2189     #define PUBL(name) pcre16_##name
2190     #define PRIV(name) _pcre16_##name
2191     #else
2192     #error Unsupported compiling mode
2193     #endif /* COMPILE_PCRE16 */
2194     #endif /* COMPILE_PCRE8 */
2195    
2196 nigel 87 /* Layout of the UCP type table that translates property names into types and
2197 ph10 240 codes. Each entry used to point directly to a name, but to reduce the number of
2198 ph10 243 relocations in shared libraries, it now has an offset into a single string
2199 ph10 240 instead. */
2200 nigel 77
2201     typedef struct {
2202 ph10 243 pcre_uint16 name_offset;
2203 nigel 87 pcre_uint16 type;
2204     pcre_uint16 value;
2205 nigel 77 } ucp_type_table;
2206    
2207    
2208     /* Internal shared data tables. These are tables that are used by more than one
2209     of the exported public functions. They have to be "external" in the C sense,
2210     but are not part of the PCRE public API. The data for these tables is in the
2211     pcre_tables.c module. */
2212    
2213 ph10 836 #ifdef COMPILE_PCRE8
2214 nigel 77
2215 ph10 836 extern const int PRIV(utf8_table1)[];
2216     extern const int PRIV(utf8_table1_size);
2217     extern const int PRIV(utf8_table2)[];
2218     extern const int PRIV(utf8_table3)[];
2219     extern const pcre_uint8 PRIV(utf8_table4)[];
2220 ph10 667
2221 ph10 836 #endif /* COMPILE_PCRE8 */
2222 nigel 77
2223 ph10 836 extern const char PRIV(utt_names)[];
2224     extern const ucp_type_table PRIV(utt)[];
2225     extern const int PRIV(utt_size);
2226 nigel 77
2227 ph10 836 extern const pcre_uint8 PRIV(default_tables)[];
2228 nigel 77
2229 ph10 836 extern const pcre_uint8 PRIV(OP_lengths)[];
2230 nigel 77
2231    
2232     /* Internal shared functions. These are functions that are used by more than
2233     one of the exported public functions. They have to be "external" in the C
2234     sense, but are not part of the PCRE public API. */
2235    
2236 ph10 836 /* String comparison functions. */
2237     #ifdef COMPILE_PCRE8
2238 nigel 77
2239 ph10 836 #define STRCMP_UC_UC(str1, str2) \
2240     strcmp((char *)(str1), (char *)(str2))
2241     #define STRCMP_UC_C8(str1, str2) \
2242     strcmp((char *)(str1), (str2))
2243     #define STRNCMP_UC_UC(str1, str2, num) \
2244     strncmp((char *)(str1), (char *)(str2), (num))
2245     #define STRNCMP_UC_C8(str1, str2, num) \
2246     strncmp((char *)(str1), (str2), (num))
2247     #define STRLEN_UC(str) strlen((const char *)str)
2248    
2249     #else
2250    
2251     extern int PRIV(strcmp_uc_uc)(const pcre_uchar *,
2252     const pcre_uchar *);
2253     extern int PRIV(strcmp_uc_c8)(const pcre_uchar *,
2254     const char *);
2255     extern int PRIV(strncmp_uc_uc)(const pcre_uchar *,
2256     const pcre_uchar *, unsigned int num);
2257     extern int PRIV(strncmp_uc_c8)(const pcre_uchar *,
2258     const char *, unsigned int num);
2259     extern unsigned int PRIV(strlen_uc)(const pcre_uchar *str);
2260    
2261     #define STRCMP_UC_UC(str1, str2) \
2262     PRIV(strcmp_uc_uc)((str1), (str2))
2263     #define STRCMP_UC_C8(str1, str2) \
2264     PRIV(strcmp_uc_c8)((str1), (str2))
2265     #define STRNCMP_UC_UC(str1, str2, num) \
2266     PRIV(strncmp_uc_uc)((str1), (str2), (num))
2267     #define STRNCMP_UC_C8(str1, str2, num) \
2268     PRIV(strncmp_uc_c8)((str1), (str2), (num))
2269     #define STRLEN_UC(str) PRIV(strlen_uc)(str)
2270    
2271     #endif /* COMPILE_PCRE8 */
2272    
2273     extern const pcre_uchar *PRIV(find_bracket)(const pcre_uchar *, BOOL, int);
2274     extern BOOL PRIV(is_newline)(PCRE_PUCHAR, int, PCRE_PUCHAR,
2275     int *, BOOL);
2276     extern int PRIV(ord2utf)(pcre_uint32, pcre_uchar *);
2277     extern int PRIV(valid_utf)(PCRE_PUCHAR, int, int *);
2278     extern BOOL PRIV(was_newline)(PCRE_PUCHAR, int, PCRE_PUCHAR,
2279     int *, BOOL);
2280     extern BOOL PRIV(xclass)(int, const pcre_uchar *, BOOL);
2281    
2282 ph10 667 #ifdef SUPPORT_JIT
2283 zherczeg 852 extern void PRIV(jit_compile)(const REAL_PCRE *, PUBL(extra) *);
2284     extern int PRIV(jit_exec)(const REAL_PCRE *, void *,
2285 ph10 836 const pcre_uchar *, int, int, int, int, int *, int);
2286     extern void PRIV(jit_free)(void *);
2287     extern int PRIV(jit_get_size)(void *);
2288 zherczeg 884 extern const char* PRIV(jit_get_target)(void);
2289 ph10 667 #endif
2290 ph10 349
2291     /* Unicode character database (UCD) */
2292    
2293     typedef struct {
2294 ph10 836 pcre_uint8 script;
2295     pcre_uint8 chartype;
2296 ph10 351 pcre_int32 other_case;
2297 ph10 349 } ucd_record;
2298    
2299 ph10 836 extern const ucd_record PRIV(ucd_records)[];
2300     extern const pcre_uint8 PRIV(ucd_stage1)[];
2301     extern const pcre_uint16 PRIV(ucd_stage2)[];
2302     extern const int PRIV(ucp_gentype)[];
2303 ph10 667 #ifdef SUPPORT_JIT
2304 ph10 836 extern const int PRIV(ucp_typerange)[];
2305 ph10 667 #endif
2306 ph10 349
2307 ph10 836 #ifdef SUPPORT_UCP
2308 ph10 349 /* UCD access macros */
2309    
2310     #define UCD_BLOCK_SIZE 128
2311 ph10 836 #define GET_UCD(ch) (PRIV(ucd_records) + \
2312     PRIV(ucd_stage2)[PRIV(ucd_stage1)[(ch) / UCD_BLOCK_SIZE] * \
2313 ph10 593 UCD_BLOCK_SIZE + (ch) % UCD_BLOCK_SIZE])
2314 ph10 349
2315     #define UCD_CHARTYPE(ch) GET_UCD(ch)->chartype
2316     #define UCD_SCRIPT(ch) GET_UCD(ch)->script
2317 ph10 836 #define UCD_CATEGORY(ch) PRIV(ucp_gentype)[UCD_CHARTYPE(ch)]
2318 ph10 351 #define UCD_OTHERCASE(ch) (ch + GET_UCD(ch)->other_case)
2319 ph10 349
2320 ph10 836 #endif /* SUPPORT_UCP */
2321    
2322 nigel 85 #endif
2323    
2324 nigel 77 /* End of pcre_internal.h */

Properties

Name Value
svn:eol-style native
svn:keywords "Author Date Id Revision Url"

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12