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