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