Annotation of win32/pcre/pcre_internal.h, revision 1.1
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
! 10: Copyright (c) 1997-2008 University of Cambridge
! 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:
! 54: /* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
! 55: inline, and there are *still* stupid compilers about that don't like indented
! 56: pre-processor statements, or at least there were when I first wrote this. After
! 57: all, it had only been about 10 years then...
! 58:
! 59: It turns out that the Mac Debugging.h header also defines the macro DPRINTF, so
! 60: be absolutely sure we get our version. */
! 61:
! 62: #undef DPRINTF
! 63: #ifdef DEBUG
! 64: #define DPRINTF(p) printf p
! 65: #else
! 66: #define DPRINTF(p) /* Nothing */
! 67: #endif
! 68:
! 69:
! 70: /* Standard C headers plus the external interface definition. The only time
! 71: setjmp and stdarg are used is when NO_RECURSE is set. */
! 72:
! 73: #include <ctype.h>
! 74: #include <limits.h>
! 75: #include <setjmp.h>
! 76: #include <stdarg.h>
! 77: #include <stddef.h>
! 78: #include <stdio.h>
! 79: #include <stdlib.h>
! 80: #include <string.h>
! 81:
! 82: /* When compiling a DLL for Windows, the exported symbols have to be declared
! 83: using some MS magic. I found some useful information on this web page:
! 84: http://msdn2.microsoft.com/en-us/library/y4h7bcy6(VS.80).aspx. According to the
! 85: information there, using __declspec(dllexport) without "extern" we have a
! 86: definition; with "extern" we have a declaration. The settings here override the
! 87: setting in pcre.h (which is included below); it defines only PCRE_EXP_DECL,
! 88: which is all that is needed for applications (they just import the symbols). We
! 89: use:
! 90:
! 91: PCRE_EXP_DECL for declarations
! 92: PCRE_EXP_DEFN for definitions of exported functions
! 93: PCRE_EXP_DATA_DEFN for definitions of exported variables
! 94:
! 95: The reason for the two DEFN macros is that in non-Windows environments, one
! 96: does not want to have "extern" before variable definitions because it leads to
! 97: compiler warnings. So we distinguish between functions and variables. In
! 98: Windows, the two should always be the same.
! 99:
! 100: The reason for wrapping this in #ifndef PCRE_EXP_DECL is so that pcretest,
! 101: which is an application, but needs to import this file in order to "peek" at
! 102: internals, can #include pcre.h first to get an application's-eye view.
! 103:
! 104: In principle, people compiling for non-Windows, non-Unix-like (i.e. uncommon,
! 105: special-purpose environments) might want to stick other stuff in front of
! 106: exported symbols. That's why, in the non-Windows case, we set PCRE_EXP_DEFN and
! 107: PCRE_EXP_DATA_DEFN only if they are not already set. */
! 108:
! 109: #ifndef PCRE_EXP_DECL
! 110: # ifdef _WIN32
! 111: # ifndef PCRE_STATIC
! 112: # define PCRE_EXP_DECL extern __declspec(dllexport)
! 113: # define PCRE_EXP_DEFN __declspec(dllexport)
! 114: # define PCRE_EXP_DATA_DEFN __declspec(dllexport)
! 115: # else
! 116: # define PCRE_EXP_DECL extern
! 117: # define PCRE_EXP_DEFN
! 118: # define PCRE_EXP_DATA_DEFN
! 119: # endif
! 120: # else
! 121: # ifdef __cplusplus
! 122: # define PCRE_EXP_DECL extern "C"
! 123: # else
! 124: # define PCRE_EXP_DECL extern
! 125: # endif
! 126: # ifndef PCRE_EXP_DEFN
! 127: # define PCRE_EXP_DEFN PCRE_EXP_DECL
! 128: # endif
! 129: # ifndef PCRE_EXP_DATA_DEFN
! 130: # define PCRE_EXP_DATA_DEFN
! 131: # endif
! 132: # endif
! 133: #endif
! 134:
! 135: /* We need to have types that specify unsigned 16-bit and 32-bit integers. We
! 136: cannot determine these outside the compilation (e.g. by running a program as
! 137: part of "configure") because PCRE is often cross-compiled for use on other
! 138: systems. Instead we make use of the maximum sizes that are available at
! 139: preprocessor time in standard C environments. */
! 140:
! 141: #if USHRT_MAX == 65535
! 142: typedef unsigned short pcre_uint16;
! 143: #elif UINT_MAX == 65535
! 144: typedef unsigned int pcre_uint16;
! 145: #else
! 146: #error Cannot determine a type for 16-bit unsigned integers
! 147: #endif
! 148:
! 149: #if UINT_MAX == 4294967295
! 150: typedef unsigned int pcre_uint32;
! 151: #elif ULONG_MAX == 4294967295
! 152: typedef unsigned long int pcre_uint32;
! 153: #else
! 154: #error Cannot determine a type for 32-bit unsigned integers
! 155: #endif
! 156:
! 157: /* All character handling must be done as unsigned characters. Otherwise there
! 158: are problems with top-bit-set characters and functions such as isspace().
! 159: However, we leave the interface to the outside world as char *, because that
! 160: should make things easier for callers. We define a short type for unsigned char
! 161: to save lots of typing. I tried "uchar", but it causes problems on Digital
! 162: Unix, where it is defined in sys/types, so use "uschar" instead. */
! 163:
! 164: typedef unsigned char uschar;
! 165:
! 166: /* This is an unsigned int value that no character can ever have. UTF-8
! 167: characters only go up to 0x7fffffff (though Unicode doesn't go beyond
! 168: 0x0010ffff). */
! 169:
! 170: #define NOTACHAR 0xffffffff
! 171:
! 172: /* PCRE is able to support several different kinds of newline (CR, LF, CRLF,
! 173: "any" and "anycrlf" at present). The following macros are used to package up
! 174: testing for newlines. NLBLOCK, PSSTART, and PSEND are defined in the various
! 175: modules to indicate in which datablock the parameters exist, and what the
! 176: start/end of string field names are. */
! 177:
! 178: #define NLTYPE_FIXED 0 /* Newline is a fixed length string */
! 179: #define NLTYPE_ANY 1 /* Newline is any Unicode line ending */
! 180: #define NLTYPE_ANYCRLF 2 /* Newline is CR, LF, or CRLF */
! 181:
! 182: /* This macro checks for a newline at the given position */
! 183:
! 184: #define IS_NEWLINE(p) \
! 185: ((NLBLOCK->nltype != NLTYPE_FIXED)? \
! 186: ((p) < NLBLOCK->PSEND && \
! 187: _pcre_is_newline((p), NLBLOCK->nltype, NLBLOCK->PSEND, &(NLBLOCK->nllen),\
! 188: utf8)) \
! 189: : \
! 190: ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \
! 191: (p)[0] == NLBLOCK->nl[0] && \
! 192: (NLBLOCK->nllen == 1 || (p)[1] == NLBLOCK->nl[1]) \
! 193: ) \
! 194: )
! 195:
! 196: /* This macro checks for a newline immediately preceding the given position */
! 197:
! 198: #define WAS_NEWLINE(p) \
! 199: ((NLBLOCK->nltype != NLTYPE_FIXED)? \
! 200: ((p) > NLBLOCK->PSSTART && \
! 201: _pcre_was_newline((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \
! 202: &(NLBLOCK->nllen), utf8)) \
! 203: : \
! 204: ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \
! 205: (p)[-NLBLOCK->nllen] == NLBLOCK->nl[0] && \
! 206: (NLBLOCK->nllen == 1 || (p)[-NLBLOCK->nllen+1] == NLBLOCK->nl[1]) \
! 207: ) \
! 208: )
! 209:
! 210: /* When PCRE is compiled as a C++ library, the subject pointer can be replaced
! 211: with a custom type. This makes it possible, for example, to allow pcre_exec()
! 212: to process subject strings that are discontinuous by using a smart pointer
! 213: class. It must always be possible to inspect all of the subject string in
! 214: pcre_exec() because of the way it backtracks. Two macros are required in the
! 215: normal case, for sign-unspecified and unsigned char pointers. The former is
! 216: used for the external interface and appears in pcre.h, which is why its name
! 217: must begin with PCRE_. */
! 218:
! 219: #ifdef CUSTOM_SUBJECT_PTR
! 220: #define PCRE_SPTR CUSTOM_SUBJECT_PTR
! 221: #define USPTR CUSTOM_SUBJECT_PTR
! 222: #else
! 223: #define PCRE_SPTR const char *
! 224: #define USPTR const unsigned char *
! 225: #endif
! 226:
! 227:
! 228:
! 229: /* Include the public PCRE header and the definitions of UCP character property
! 230: values. */
! 231:
! 232: #include "pcre.h"
! 233: #include "ucp.h"
! 234:
! 235: /* When compiling for use with the Virtual Pascal compiler, these functions
! 236: need to have their names changed. PCRE must be compiled with the -DVPCOMPAT
! 237: option on the command line. */
! 238:
! 239: #ifdef VPCOMPAT
! 240: #define strlen(s) _strlen(s)
! 241: #define strncmp(s1,s2,m) _strncmp(s1,s2,m)
! 242: #define memcmp(s,c,n) _memcmp(s,c,n)
! 243: #define memcpy(d,s,n) _memcpy(d,s,n)
! 244: #define memmove(d,s,n) _memmove(d,s,n)
! 245: #define memset(s,c,n) _memset(s,c,n)
! 246: #else /* VPCOMPAT */
! 247:
! 248: /* To cope with SunOS4 and other systems that lack memmove() but have bcopy(),
! 249: define a macro for memmove() if HAVE_MEMMOVE is false, provided that HAVE_BCOPY
! 250: is set. Otherwise, include an emulating function for those systems that have
! 251: neither (there some non-Unix environments where this is the case). */
! 252:
! 253: #ifndef HAVE_MEMMOVE
! 254: #undef memmove /* some systems may have a macro */
! 255: #ifdef HAVE_BCOPY
! 256: #define memmove(a, b, c) bcopy(b, a, c)
! 257: #else /* HAVE_BCOPY */
! 258: static void *
! 259: pcre_memmove(void *d, const void *s, size_t n)
! 260: {
! 261: size_t i;
! 262: unsigned char *dest = (unsigned char *)d;
! 263: const unsigned char *src = (const unsigned char *)s;
! 264: if (dest > src)
! 265: {
! 266: dest += n;
! 267: src += n;
! 268: for (i = 0; i < n; ++i) *(--dest) = *(--src);
! 269: return (void *)dest;
! 270: }
! 271: else
! 272: {
! 273: for (i = 0; i < n; ++i) *dest++ = *src++;
! 274: return (void *)(dest - n);
! 275: }
! 276: }
! 277: #define memmove(a, b, c) pcre_memmove(a, b, c)
! 278: #endif /* not HAVE_BCOPY */
! 279: #endif /* not HAVE_MEMMOVE */
! 280: #endif /* not VPCOMPAT */
! 281:
! 282:
! 283: /* PCRE keeps offsets in its compiled code as 2-byte quantities (always stored
! 284: in big-endian order) by default. These are used, for example, to link from the
! 285: start of a subpattern to its alternatives and its end. The use of 2 bytes per
! 286: offset limits the size of the compiled regex to around 64K, which is big enough
! 287: for almost everybody. However, I received a request for an even bigger limit.
! 288: For this reason, and also to make the code easier to maintain, the storing and
! 289: loading of offsets from the byte string is now handled by the macros that are
! 290: defined here.
! 291:
! 292: The macros are controlled by the value of LINK_SIZE. This defaults to 2 in
! 293: the config.h file, but can be overridden by using -D on the command line. This
! 294: is automated on Unix systems via the "configure" command. */
! 295:
! 296: #if LINK_SIZE == 2
! 297:
! 298: #define PUT(a,n,d) \
! 299: (a[n] = (d) >> 8), \
! 300: (a[(n)+1] = (d) & 255)
! 301:
! 302: #define GET(a,n) \
! 303: (((a)[n] << 8) | (a)[(n)+1])
! 304:
! 305: #define MAX_PATTERN_SIZE (1 << 16)
! 306:
! 307:
! 308: #elif LINK_SIZE == 3
! 309:
! 310: #define PUT(a,n,d) \
! 311: (a[n] = (d) >> 16), \
! 312: (a[(n)+1] = (d) >> 8), \
! 313: (a[(n)+2] = (d) & 255)
! 314:
! 315: #define GET(a,n) \
! 316: (((a)[n] << 16) | ((a)[(n)+1] << 8) | (a)[(n)+2])
! 317:
! 318: #define MAX_PATTERN_SIZE (1 << 24)
! 319:
! 320:
! 321: #elif LINK_SIZE == 4
! 322:
! 323: #define PUT(a,n,d) \
! 324: (a[n] = (d) >> 24), \
! 325: (a[(n)+1] = (d) >> 16), \
! 326: (a[(n)+2] = (d) >> 8), \
! 327: (a[(n)+3] = (d) & 255)
! 328:
! 329: #define GET(a,n) \
! 330: (((a)[n] << 24) | ((a)[(n)+1] << 16) | ((a)[(n)+2] << 8) | (a)[(n)+3])
! 331:
! 332: #define MAX_PATTERN_SIZE (1 << 30) /* Keep it positive */
! 333:
! 334:
! 335: #else
! 336: #error LINK_SIZE must be either 2, 3, or 4
! 337: #endif
! 338:
! 339:
! 340: /* Convenience macro defined in terms of the others */
! 341:
! 342: #define PUTINC(a,n,d) PUT(a,n,d), a += LINK_SIZE
! 343:
! 344:
! 345: /* PCRE uses some other 2-byte quantities that do not change when the size of
! 346: offsets changes. There are used for repeat counts and for other things such as
! 347: capturing parenthesis numbers in back references. */
! 348:
! 349: #define PUT2(a,n,d) \
! 350: a[n] = (d) >> 8; \
! 351: a[(n)+1] = (d) & 255
! 352:
! 353: #define GET2(a,n) \
! 354: (((a)[n] << 8) | (a)[(n)+1])
! 355:
! 356: #define PUT2INC(a,n,d) PUT2(a,n,d), a += 2
! 357:
! 358:
! 359: /* When UTF-8 encoding is being used, a character is no longer just a single
! 360: byte. The macros for character handling generate simple sequences when used in
! 361: byte-mode, and more complicated ones for UTF-8 characters. BACKCHAR should
! 362: never be called in byte mode. To make sure it can never even appear when UTF-8
! 363: support is omitted, we don't even define it. */
! 364:
! 365: #ifndef SUPPORT_UTF8
! 366: #define NEXTCHAR(p) p++;
! 367: #define GETCHAR(c, eptr) c = *eptr;
! 368: #define GETCHARTEST(c, eptr) c = *eptr;
! 369: #define GETCHARINC(c, eptr) c = *eptr++;
! 370: #define GETCHARINCTEST(c, eptr) c = *eptr++;
! 371: #define GETCHARLEN(c, eptr, len) c = *eptr;
! 372: /* #define BACKCHAR(eptr) */
! 373:
! 374: #else /* SUPPORT_UTF8 */
! 375:
! 376: /* Advance a character pointer one byte in non-UTF-8 mode and by one character
! 377: in UTF-8 mode. */
! 378:
! 379: #define NEXTCHAR(p) \
! 380: p++; \
! 381: if (utf8) { while((*p & 0xc0) == 0x80) p++; }
! 382:
! 383: /* Get the next UTF-8 character, not advancing the pointer. This is called when
! 384: we know we are in UTF-8 mode. */
! 385:
! 386: #define GETCHAR(c, eptr) \
! 387: c = *eptr; \
! 388: if (c >= 0xc0) \
! 389: { \
! 390: int gcii; \
! 391: int gcaa = _pcre_utf8_table4[c & 0x3f]; /* Number of additional bytes */ \
! 392: int gcss = 6*gcaa; \
! 393: c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
! 394: for (gcii = 1; gcii <= gcaa; gcii++) \
! 395: { \
! 396: gcss -= 6; \
! 397: c |= (eptr[gcii] & 0x3f) << gcss; \
! 398: } \
! 399: }
! 400:
! 401: /* Get the next UTF-8 character, testing for UTF-8 mode, and not advancing the
! 402: pointer. */
! 403:
! 404: #define GETCHARTEST(c, eptr) \
! 405: c = *eptr; \
! 406: if (utf8 && c >= 0xc0) \
! 407: { \
! 408: int gcii; \
! 409: int gcaa = _pcre_utf8_table4[c & 0x3f]; /* Number of additional bytes */ \
! 410: int gcss = 6*gcaa; \
! 411: c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
! 412: for (gcii = 1; gcii <= gcaa; gcii++) \
! 413: { \
! 414: gcss -= 6; \
! 415: c |= (eptr[gcii] & 0x3f) << gcss; \
! 416: } \
! 417: }
! 418:
! 419: /* Get the next UTF-8 character, advancing the pointer. This is called when we
! 420: know we are in UTF-8 mode. */
! 421:
! 422: #define GETCHARINC(c, eptr) \
! 423: c = *eptr++; \
! 424: if (c >= 0xc0) \
! 425: { \
! 426: int gcaa = _pcre_utf8_table4[c & 0x3f]; /* Number of additional bytes */ \
! 427: int gcss = 6*gcaa; \
! 428: c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
! 429: while (gcaa-- > 0) \
! 430: { \
! 431: gcss -= 6; \
! 432: c |= (*eptr++ & 0x3f) << gcss; \
! 433: } \
! 434: }
! 435:
! 436: /* Get the next character, testing for UTF-8 mode, and advancing the pointer */
! 437:
! 438: #define GETCHARINCTEST(c, eptr) \
! 439: c = *eptr++; \
! 440: if (utf8 && c >= 0xc0) \
! 441: { \
! 442: int gcaa = _pcre_utf8_table4[c & 0x3f]; /* Number of additional bytes */ \
! 443: int gcss = 6*gcaa; \
! 444: c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
! 445: while (gcaa-- > 0) \
! 446: { \
! 447: gcss -= 6; \
! 448: c |= (*eptr++ & 0x3f) << gcss; \
! 449: } \
! 450: }
! 451:
! 452: /* Get the next UTF-8 character, not advancing the pointer, incrementing length
! 453: if there are extra bytes. This is called when we know we are in UTF-8 mode. */
! 454:
! 455: #define GETCHARLEN(c, eptr, len) \
! 456: c = *eptr; \
! 457: if (c >= 0xc0) \
! 458: { \
! 459: int gcii; \
! 460: int gcaa = _pcre_utf8_table4[c & 0x3f]; /* Number of additional bytes */ \
! 461: int gcss = 6*gcaa; \
! 462: c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
! 463: for (gcii = 1; gcii <= gcaa; gcii++) \
! 464: { \
! 465: gcss -= 6; \
! 466: c |= (eptr[gcii] & 0x3f) << gcss; \
! 467: } \
! 468: len += gcaa; \
! 469: }
! 470:
! 471: /* If the pointer is not at the start of a character, move it back until
! 472: it is. This is called only in UTF-8 mode - we don't put a test within the macro
! 473: because almost all calls are already within a block of UTF-8 only code. */
! 474:
! 475: #define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--
! 476:
! 477: #endif
! 478:
! 479:
! 480: /* In case there is no definition of offsetof() provided - though any proper
! 481: Standard C system should have one. */
! 482:
! 483: #ifndef offsetof
! 484: #define offsetof(p_type,field) ((size_t)&(((p_type *)0)->field))
! 485: #endif
! 486:
! 487:
! 488: /* These are the public options that can change during matching. */
! 489:
! 490: #define PCRE_IMS (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL)
! 491:
! 492: /* Private flags containing information about the compiled regex. They used to
! 493: live at the top end of the options word, but that got almost full, so now they
! 494: are in a 16-bit flags word. */
! 495:
! 496: #define PCRE_NOPARTIAL 0x0001 /* can't use partial with this regex */
! 497: #define PCRE_FIRSTSET 0x0002 /* first_byte is set */
! 498: #define PCRE_REQCHSET 0x0004 /* req_byte is set */
! 499: #define PCRE_STARTLINE 0x0008 /* start after \n for multiline */
! 500: #define PCRE_JCHANGED 0x0010 /* j option used in regex */
! 501: #define PCRE_HASCRORLF 0x0020 /* explicit \r or \n in pattern */
! 502:
! 503: /* Options for the "extra" block produced by pcre_study(). */
! 504:
! 505: #define PCRE_STUDY_MAPPED 0x01 /* a map of starting chars exists */
! 506:
! 507: /* Masks for identifying the public options that are permitted at compile
! 508: time, run time, or study time, respectively. */
! 509:
! 510: #define PCRE_NEWLINE_BITS (PCRE_NEWLINE_CR|PCRE_NEWLINE_LF|PCRE_NEWLINE_ANY| \
! 511: PCRE_NEWLINE_ANYCRLF)
! 512:
! 513: #define PUBLIC_OPTIONS \
! 514: (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \
! 515: PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY|PCRE_UTF8| \
! 516: PCRE_NO_AUTO_CAPTURE|PCRE_NO_UTF8_CHECK|PCRE_AUTO_CALLOUT|PCRE_FIRSTLINE| \
! 517: PCRE_DUPNAMES|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE| \
! 518: PCRE_JAVASCRIPT_COMPAT)
! 519:
! 520: #define PUBLIC_EXEC_OPTIONS \
! 521: (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \
! 522: PCRE_PARTIAL|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)
! 523:
! 524: #define PUBLIC_DFA_EXEC_OPTIONS \
! 525: (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \
! 526: PCRE_PARTIAL|PCRE_DFA_SHORTEST|PCRE_DFA_RESTART|PCRE_NEWLINE_BITS| \
! 527: PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)
! 528:
! 529: #define PUBLIC_STUDY_OPTIONS 0 /* None defined */
! 530:
! 531: /* Magic number to provide a small check against being handed junk. Also used
! 532: to detect whether a pattern was compiled on a host of different endianness. */
! 533:
! 534: #define MAGIC_NUMBER 0x50435245UL /* 'PCRE' */
! 535:
! 536: /* Negative values for the firstchar and reqchar variables */
! 537:
! 538: #define REQ_UNSET (-2)
! 539: #define REQ_NONE (-1)
! 540:
! 541: /* The maximum remaining length of subject we are prepared to search for a
! 542: req_byte match. */
! 543:
! 544: #define REQ_BYTE_MAX 1000
! 545:
! 546: /* Flags added to firstbyte or reqbyte; a "non-literal" item is either a
! 547: variable-length repeat, or a anything other than literal characters. */
! 548:
! 549: #define REQ_CASELESS 0x0100 /* indicates caselessness */
! 550: #define REQ_VARY 0x0200 /* reqbyte followed non-literal item */
! 551:
! 552: /* Miscellaneous definitions */
! 553:
! 554: typedef int BOOL;
! 555:
! 556: #define FALSE 0
! 557: #define TRUE 1
! 558:
! 559: /* Escape items that are just an encoding of a particular data value. */
! 560:
! 561: #ifndef ESC_e
! 562: #define ESC_e 27
! 563: #endif
! 564:
! 565: #ifndef ESC_f
! 566: #define ESC_f '\f'
! 567: #endif
! 568:
! 569: #ifndef ESC_n
! 570: #define ESC_n '\n'
! 571: #endif
! 572:
! 573: #ifndef ESC_r
! 574: #define ESC_r '\r'
! 575: #endif
! 576:
! 577: /* We can't officially use ESC_t because it is a POSIX reserved identifier
! 578: (presumably because of all the others like size_t). */
! 579:
! 580: #ifndef ESC_tee
! 581: #define ESC_tee '\t'
! 582: #endif
! 583:
! 584: /* Codes for different types of Unicode property */
! 585:
! 586: #define PT_ANY 0 /* Any property - matches all chars */
! 587: #define PT_LAMP 1 /* L& - the union of Lu, Ll, Lt */
! 588: #define PT_GC 2 /* General characteristic (e.g. L) */
! 589: #define PT_PC 3 /* Particular characteristic (e.g. Lu) */
! 590: #define PT_SC 4 /* Script (e.g. Han) */
! 591:
! 592: /* Flag bits and data types for the extended class (OP_XCLASS) for classes that
! 593: contain UTF-8 characters with values greater than 255. */
! 594:
! 595: #define XCL_NOT 0x01 /* Flag: this is a negative class */
! 596: #define XCL_MAP 0x02 /* Flag: a 32-byte map is present */
! 597:
! 598: #define XCL_END 0 /* Marks end of individual items */
! 599: #define XCL_SINGLE 1 /* Single item (one multibyte char) follows */
! 600: #define XCL_RANGE 2 /* A range (two multibyte chars) follows */
! 601: #define XCL_PROP 3 /* Unicode property (2-byte property code follows) */
! 602: #define XCL_NOTPROP 4 /* Unicode inverted property (ditto) */
! 603:
! 604: /* These are escaped items that aren't just an encoding of a particular data
! 605: value such as \n. They must have non-zero values, as check_escape() returns
! 606: their negation. Also, they must appear in the same order as in the opcode
! 607: definitions below, up to ESC_z. There's a dummy for OP_ANY because it
! 608: corresponds to "." rather than an escape sequence, and another for OP_ALLANY
! 609: (which is used for [^] in JavaScript compatibility mode).
! 610:
! 611: The final escape must be ESC_REF as subsequent values are used for
! 612: backreferences (\1, \2, \3, etc). There are two tests in the code for an escape
! 613: greater than ESC_b and less than ESC_Z to detect the types that may be
! 614: repeated. These are the types that consume characters. If any new escapes are
! 615: put in between that don't consume a character, that code will have to change.
! 616: */
! 617:
! 618: enum { ESC_A = 1, ESC_G, ESC_K, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s,
! 619: ESC_W, ESC_w, ESC_dum1, ESC_dum2, ESC_C, ESC_P, ESC_p, ESC_R, ESC_H,
! 620: ESC_h, ESC_V, ESC_v, ESC_X, ESC_Z, ESC_z, ESC_E, ESC_Q, ESC_g, ESC_k,
! 621: ESC_REF };
! 622:
! 623:
! 624: /* Opcode table: Starting from 1 (i.e. after OP_END), the values up to
! 625: OP_EOD must correspond in order to the list of escapes immediately above.
! 626:
! 627: *** NOTE NOTE NOTE *** Whenever this list is updated, the two macro definitions
! 628: that follow must also be updated to match. There is also a table called
! 629: "coptable" in pcre_dfa_exec.c that must be updated. */
! 630:
! 631: enum {
! 632: OP_END, /* 0 End of pattern */
! 633:
! 634: /* Values corresponding to backslashed metacharacters */
! 635:
! 636: OP_SOD, /* 1 Start of data: \A */
! 637: OP_SOM, /* 2 Start of match (subject + offset): \G */
! 638: OP_SET_SOM, /* 3 Set start of match (\K) */
! 639: OP_NOT_WORD_BOUNDARY, /* 4 \B */
! 640: OP_WORD_BOUNDARY, /* 5 \b */
! 641: OP_NOT_DIGIT, /* 6 \D */
! 642: OP_DIGIT, /* 7 \d */
! 643: OP_NOT_WHITESPACE, /* 8 \S */
! 644: OP_WHITESPACE, /* 9 \s */
! 645: OP_NOT_WORDCHAR, /* 10 \W */
! 646: OP_WORDCHAR, /* 11 \w */
! 647: OP_ANY, /* 12 Match any character (subject to DOTALL) */
! 648: OP_ALLANY, /* 13 Match any character (not subject to DOTALL) */
! 649: OP_ANYBYTE, /* 14 Match any byte (\C); different to OP_ANY for UTF-8 */
! 650: OP_NOTPROP, /* 15 \P (not Unicode property) */
! 651: OP_PROP, /* 16 \p (Unicode property) */
! 652: OP_ANYNL, /* 17 \R (any newline sequence) */
! 653: OP_NOT_HSPACE, /* 18 \H (not horizontal whitespace) */
! 654: OP_HSPACE, /* 19 \h (horizontal whitespace) */
! 655: OP_NOT_VSPACE, /* 20 \V (not vertical whitespace) */
! 656: OP_VSPACE, /* 21 \v (vertical whitespace) */
! 657: OP_EXTUNI, /* 22 \X (extended Unicode sequence */
! 658: OP_EODN, /* 23 End of data or \n at end of data: \Z. */
! 659: OP_EOD, /* 24 End of data: \z */
! 660:
! 661: OP_OPT, /* 25 Set runtime options */
! 662: OP_CIRC, /* 26 Start of line - varies with multiline switch */
! 663: OP_DOLL, /* 27 End of line - varies with multiline switch */
! 664: OP_CHAR, /* 28 Match one character, casefully */
! 665: OP_CHARNC, /* 29 Match one character, caselessly */
! 666: OP_NOT, /* 30 Match one character, not the following one */
! 667:
! 668: OP_STAR, /* 31 The maximizing and minimizing versions of */
! 669: OP_MINSTAR, /* 32 these six opcodes must come in pairs, with */
! 670: OP_PLUS, /* 33 the minimizing one second. */
! 671: OP_MINPLUS, /* 34 This first set applies to single characters.*/
! 672: OP_QUERY, /* 35 */
! 673: OP_MINQUERY, /* 36 */
! 674:
! 675: OP_UPTO, /* 37 From 0 to n matches */
! 676: OP_MINUPTO, /* 38 */
! 677: OP_EXACT, /* 39 Exactly n matches */
! 678:
! 679: OP_POSSTAR, /* 40 Possessified star */
! 680: OP_POSPLUS, /* 41 Possessified plus */
! 681: OP_POSQUERY, /* 42 Posesssified query */
! 682: OP_POSUPTO, /* 43 Possessified upto */
! 683:
! 684: OP_NOTSTAR, /* 44 The maximizing and minimizing versions of */
! 685: OP_NOTMINSTAR, /* 45 these six opcodes must come in pairs, with */
! 686: OP_NOTPLUS, /* 46 the minimizing one second. They must be in */
! 687: OP_NOTMINPLUS, /* 47 exactly the same order as those above. */
! 688: OP_NOTQUERY, /* 48 This set applies to "not" single characters. */
! 689: OP_NOTMINQUERY, /* 49 */
! 690:
! 691: OP_NOTUPTO, /* 50 From 0 to n matches */
! 692: OP_NOTMINUPTO, /* 51 */
! 693: OP_NOTEXACT, /* 52 Exactly n matches */
! 694:
! 695: OP_NOTPOSSTAR, /* 53 Possessified versions */
! 696: OP_NOTPOSPLUS, /* 54 */
! 697: OP_NOTPOSQUERY, /* 55 */
! 698: OP_NOTPOSUPTO, /* 56 */
! 699:
! 700: OP_TYPESTAR, /* 57 The maximizing and minimizing versions of */
! 701: OP_TYPEMINSTAR, /* 58 these six opcodes must come in pairs, with */
! 702: OP_TYPEPLUS, /* 59 the minimizing one second. These codes must */
! 703: OP_TYPEMINPLUS, /* 60 be in exactly the same order as those above. */
! 704: OP_TYPEQUERY, /* 61 This set applies to character types such as \d */
! 705: OP_TYPEMINQUERY, /* 62 */
! 706:
! 707: OP_TYPEUPTO, /* 63 From 0 to n matches */
! 708: OP_TYPEMINUPTO, /* 64 */
! 709: OP_TYPEEXACT, /* 65 Exactly n matches */
! 710:
! 711: OP_TYPEPOSSTAR, /* 66 Possessified versions */
! 712: OP_TYPEPOSPLUS, /* 67 */
! 713: OP_TYPEPOSQUERY, /* 68 */
! 714: OP_TYPEPOSUPTO, /* 69 */
! 715:
! 716: OP_CRSTAR, /* 70 The maximizing and minimizing versions of */
! 717: OP_CRMINSTAR, /* 71 all these opcodes must come in pairs, with */
! 718: OP_CRPLUS, /* 72 the minimizing one second. These codes must */
! 719: OP_CRMINPLUS, /* 73 be in exactly the same order as those above. */
! 720: OP_CRQUERY, /* 74 These are for character classes and back refs */
! 721: OP_CRMINQUERY, /* 75 */
! 722: OP_CRRANGE, /* 76 These are different to the three sets above. */
! 723: OP_CRMINRANGE, /* 77 */
! 724:
! 725: OP_CLASS, /* 78 Match a character class, chars < 256 only */
! 726: OP_NCLASS, /* 79 Same, but the bitmap was created from a negative
! 727: class - the difference is relevant only when a UTF-8
! 728: character > 255 is encountered. */
! 729:
! 730: OP_XCLASS, /* 80 Extended class for handling UTF-8 chars within the
! 731: class. This does both positive and negative. */
! 732:
! 733: OP_REF, /* 81 Match a back reference */
! 734: OP_RECURSE, /* 82 Match a numbered subpattern (possibly recursive) */
! 735: OP_CALLOUT, /* 83 Call out to external function if provided */
! 736:
! 737: OP_ALT, /* 84 Start of alternation */
! 738: OP_KET, /* 85 End of group that doesn't have an unbounded repeat */
! 739: OP_KETRMAX, /* 86 These two must remain together and in this */
! 740: OP_KETRMIN, /* 87 order. They are for groups the repeat for ever. */
! 741:
! 742: /* The assertions must come before BRA, CBRA, ONCE, and COND.*/
! 743:
! 744: OP_ASSERT, /* 88 Positive lookahead */
! 745: OP_ASSERT_NOT, /* 89 Negative lookahead */
! 746: OP_ASSERTBACK, /* 90 Positive lookbehind */
! 747: OP_ASSERTBACK_NOT, /* 91 Negative lookbehind */
! 748: OP_REVERSE, /* 92 Move pointer back - used in lookbehind assertions */
! 749:
! 750: /* ONCE, BRA, CBRA, and COND must come after the assertions, with ONCE first,
! 751: as there's a test for >= ONCE for a subpattern that isn't an assertion. */
! 752:
! 753: OP_ONCE, /* 93 Atomic group */
! 754: OP_BRA, /* 94 Start of non-capturing bracket */
! 755: OP_CBRA, /* 95 Start of capturing bracket */
! 756: OP_COND, /* 96 Conditional group */
! 757:
! 758: /* These three must follow the previous three, in the same order. There's a
! 759: check for >= SBRA to distinguish the two sets. */
! 760:
! 761: OP_SBRA, /* 97 Start of non-capturing bracket, check empty */
! 762: OP_SCBRA, /* 98 Start of capturing bracket, check empty */
! 763: OP_SCOND, /* 99 Conditional group, check empty */
! 764:
! 765: OP_CREF, /* 100 Used to hold a capture number as condition */
! 766: OP_RREF, /* 101 Used to hold a recursion number as condition */
! 767: OP_DEF, /* 102 The DEFINE condition */
! 768:
! 769: OP_BRAZERO, /* 103 These two must remain together and in this */
! 770: OP_BRAMINZERO, /* 104 order. */
! 771:
! 772: /* These are backtracking control verbs */
! 773:
! 774: OP_PRUNE, /* 105 */
! 775: OP_SKIP, /* 106 */
! 776: OP_THEN, /* 107 */
! 777: OP_COMMIT, /* 108 */
! 778:
! 779: /* These are forced failure and success verbs */
! 780:
! 781: OP_FAIL, /* 109 */
! 782: OP_ACCEPT, /* 110 */
! 783:
! 784: /* This is used to skip a subpattern with a {0} quantifier */
! 785:
! 786: OP_SKIPZERO /* 111 */
! 787: };
! 788:
! 789:
! 790: /* This macro defines textual names for all the opcodes. These are used only
! 791: for debugging. The macro is referenced only in pcre_printint.c. */
! 792:
! 793: #define OP_NAME_LIST \
! 794: "End", "\\A", "\\G", "\\K", "\\B", "\\b", "\\D", "\\d", \
! 795: "\\S", "\\s", "\\W", "\\w", "Any", "AllAny", "Anybyte", \
! 796: "notprop", "prop", "\\R", "\\H", "\\h", "\\V", "\\v", \
! 797: "extuni", "\\Z", "\\z", \
! 798: "Opt", "^", "$", "char", "charnc", "not", \
! 799: "*", "*?", "+", "+?", "?", "??", "{", "{", "{", \
! 800: "*+","++", "?+", "{", \
! 801: "*", "*?", "+", "+?", "?", "??", "{", "{", "{", \
! 802: "*+","++", "?+", "{", \
! 803: "*", "*?", "+", "+?", "?", "??", "{", "{", "{", \
! 804: "*+","++", "?+", "{", \
! 805: "*", "*?", "+", "+?", "?", "??", "{", "{", \
! 806: "class", "nclass", "xclass", "Ref", "Recurse", "Callout", \
! 807: "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not", \
! 808: "AssertB", "AssertB not", "Reverse", \
! 809: "Once", "Bra", "CBra", "Cond", "SBra", "SCBra", "SCond", \
! 810: "Cond ref", "Cond rec", "Cond def", "Brazero", "Braminzero", \
! 811: "*PRUNE", "*SKIP", "*THEN", "*COMMIT", "*FAIL", "*ACCEPT", \
! 812: "Skip zero"
! 813:
! 814:
! 815: /* This macro defines the length of fixed length operations in the compiled
! 816: regex. The lengths are used when searching for specific things, and also in the
! 817: debugging printing of a compiled regex. We use a macro so that it can be
! 818: defined close to the definitions of the opcodes themselves.
! 819:
! 820: As things have been extended, some of these are no longer fixed lenths, but are
! 821: minima instead. For example, the length of a single-character repeat may vary
! 822: in UTF-8 mode. The code that uses this table must know about such things. */
! 823:
! 824: #define OP_LENGTHS \
! 825: 1, /* End */ \
! 826: 1, 1, 1, 1, 1, /* \A, \G, \K, \B, \b */ \
! 827: 1, 1, 1, 1, 1, 1, /* \D, \d, \S, \s, \W, \w */ \
! 828: 1, 1, 1, /* Any, AllAny, Anybyte */ \
! 829: 3, 3, 1, /* NOTPROP, PROP, EXTUNI */ \
! 830: 1, 1, 1, 1, 1, /* \R, \H, \h, \V, \v */ \
! 831: 1, 1, 2, 1, 1, /* \Z, \z, Opt, ^, $ */ \
! 832: 2, /* Char - the minimum length */ \
! 833: 2, /* Charnc - the minimum length */ \
! 834: 2, /* not */ \
! 835: /* Positive single-char repeats ** These are */ \
! 836: 2, 2, 2, 2, 2, 2, /* *, *?, +, +?, ?, ?? ** minima in */ \
! 837: 4, 4, 4, /* upto, minupto, exact ** UTF-8 mode */ \
! 838: 2, 2, 2, 4, /* *+, ++, ?+, upto+ */ \
! 839: /* Negative single-char repeats - only for chars < 256 */ \
! 840: 2, 2, 2, 2, 2, 2, /* NOT *, *?, +, +?, ?, ?? */ \
! 841: 4, 4, 4, /* NOT upto, minupto, exact */ \
! 842: 2, 2, 2, 4, /* Possessive *, +, ?, upto */ \
! 843: /* Positive type repeats */ \
! 844: 2, 2, 2, 2, 2, 2, /* Type *, *?, +, +?, ?, ?? */ \
! 845: 4, 4, 4, /* Type upto, minupto, exact */ \
! 846: 2, 2, 2, 4, /* Possessive *+, ++, ?+, upto+ */ \
! 847: /* Character class & ref repeats */ \
! 848: 1, 1, 1, 1, 1, 1, /* *, *?, +, +?, ?, ?? */ \
! 849: 5, 5, /* CRRANGE, CRMINRANGE */ \
! 850: 33, /* CLASS */ \
! 851: 33, /* NCLASS */ \
! 852: 0, /* XCLASS - variable length */ \
! 853: 3, /* REF */ \
! 854: 1+LINK_SIZE, /* RECURSE */ \
! 855: 2+2*LINK_SIZE, /* CALLOUT */ \
! 856: 1+LINK_SIZE, /* Alt */ \
! 857: 1+LINK_SIZE, /* Ket */ \
! 858: 1+LINK_SIZE, /* KetRmax */ \
! 859: 1+LINK_SIZE, /* KetRmin */ \
! 860: 1+LINK_SIZE, /* Assert */ \
! 861: 1+LINK_SIZE, /* Assert not */ \
! 862: 1+LINK_SIZE, /* Assert behind */ \
! 863: 1+LINK_SIZE, /* Assert behind not */ \
! 864: 1+LINK_SIZE, /* Reverse */ \
! 865: 1+LINK_SIZE, /* ONCE */ \
! 866: 1+LINK_SIZE, /* BRA */ \
! 867: 3+LINK_SIZE, /* CBRA */ \
! 868: 1+LINK_SIZE, /* COND */ \
! 869: 1+LINK_SIZE, /* SBRA */ \
! 870: 3+LINK_SIZE, /* SCBRA */ \
! 871: 1+LINK_SIZE, /* SCOND */ \
! 872: 3, /* CREF */ \
! 873: 3, /* RREF */ \
! 874: 1, /* DEF */ \
! 875: 1, 1, /* BRAZERO, BRAMINZERO */ \
! 876: 1, 1, 1, 1, /* PRUNE, SKIP, THEN, COMMIT, */ \
! 877: 1, 1, 1 /* FAIL, ACCEPT, SKIPZERO */
! 878:
! 879:
! 880: /* A magic value for OP_RREF to indicate the "any recursion" condition. */
! 881:
! 882: #define RREF_ANY 0xffff
! 883:
! 884: /* Error code numbers. They are given names so that they can more easily be
! 885: tracked. */
! 886:
! 887: enum { ERR0, ERR1, ERR2, ERR3, ERR4, ERR5, ERR6, ERR7, ERR8, ERR9,
! 888: ERR10, ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19,
! 889: ERR20, ERR21, ERR22, ERR23, ERR24, ERR25, ERR26, ERR27, ERR28, ERR29,
! 890: ERR30, ERR31, ERR32, ERR33, ERR34, ERR35, ERR36, ERR37, ERR38, ERR39,
! 891: ERR40, ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47, ERR48, ERR49,
! 892: ERR50, ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57, ERR58, ERR59,
! 893: ERR60, ERR61, ERR62, ERR63, ERR64 };
! 894:
! 895: /* The real format of the start of the pcre block; the index of names and the
! 896: code vector run on as long as necessary after the end. We store an explicit
! 897: offset to the name table so that if a regex is compiled on one host, saved, and
! 898: then run on another where the size of pointers is different, all might still
! 899: be well. For the case of compiled-on-4 and run-on-8, we include an extra
! 900: pointer that is always NULL. For future-proofing, a few dummy fields were
! 901: originally included - even though you can never get this planning right - but
! 902: there is only one left now.
! 903:
! 904: NOTE NOTE NOTE:
! 905: Because people can now save and re-use compiled patterns, any additions to this
! 906: structure should be made at the end, and something earlier (e.g. a new
! 907: flag in the options or one of the dummy fields) should indicate that the new
! 908: fields are present. Currently PCRE always sets the dummy fields to zero.
! 909: NOTE NOTE NOTE:
! 910: */
! 911:
! 912: typedef struct real_pcre {
! 913: pcre_uint32 magic_number;
! 914: pcre_uint32 size; /* Total that was malloced */
! 915: pcre_uint32 options; /* Public options */
! 916: pcre_uint16 flags; /* Private flags */
! 917: pcre_uint16 dummy1; /* For future use */
! 918: pcre_uint16 top_bracket;
! 919: pcre_uint16 top_backref;
! 920: pcre_uint16 first_byte;
! 921: pcre_uint16 req_byte;
! 922: pcre_uint16 name_table_offset; /* Offset to name table that follows */
! 923: pcre_uint16 name_entry_size; /* Size of any name items */
! 924: pcre_uint16 name_count; /* Number of name items */
! 925: pcre_uint16 ref_count; /* Reference count */
! 926:
! 927: const unsigned char *tables; /* Pointer to tables or NULL for std */
! 928: const unsigned char *nullpad; /* NULL padding */
! 929: } real_pcre;
! 930:
! 931: /* The format of the block used to store data from pcre_study(). The same
! 932: remark (see NOTE above) about extending this structure applies. */
! 933:
! 934: typedef struct pcre_study_data {
! 935: pcre_uint32 size; /* Total that was malloced */
! 936: pcre_uint32 options;
! 937: uschar start_bits[32];
! 938: } pcre_study_data;
! 939:
! 940: /* Structure for passing "static" information around between the functions
! 941: doing the compiling, so that they are thread-safe. */
! 942:
! 943: typedef struct compile_data {
! 944: const uschar *lcc; /* Points to lower casing table */
! 945: const uschar *fcc; /* Points to case-flipping table */
! 946: const uschar *cbits; /* Points to character type table */
! 947: const uschar *ctypes; /* Points to table of type maps */
! 948: const uschar *start_workspace;/* The start of working space */
! 949: const uschar *start_code; /* The start of the compiled code */
! 950: const uschar *start_pattern; /* The start of the pattern */
! 951: const uschar *end_pattern; /* The end of the pattern */
! 952: uschar *hwm; /* High watermark of workspace */
! 953: uschar *name_table; /* The name/number table */
! 954: int names_found; /* Number of entries so far */
! 955: int name_entry_size; /* Size of each entry */
! 956: int bracount; /* Count of capturing parens as we compile */
! 957: int final_bracount; /* Saved value after first pass */
! 958: int top_backref; /* Maximum back reference */
! 959: unsigned int backref_map; /* Bitmap of low back refs */
! 960: int external_options; /* External (initial) options */
! 961: int external_flags; /* External flag bits to be set */
! 962: int req_varyopt; /* "After variable item" flag for reqbyte */
! 963: BOOL had_accept; /* (*ACCEPT) encountered */
! 964: int nltype; /* Newline type */
! 965: int nllen; /* Newline string length */
! 966: uschar nl[4]; /* Newline string when fixed length */
! 967: } compile_data;
! 968:
! 969: /* Structure for maintaining a chain of pointers to the currently incomplete
! 970: branches, for testing for left recursion. */
! 971:
! 972: typedef struct branch_chain {
! 973: struct branch_chain *outer;
! 974: uschar *current;
! 975: } branch_chain;
! 976:
! 977: /* Structure for items in a linked list that represents an explicit recursive
! 978: call within the pattern. */
! 979:
! 980: typedef struct recursion_info {
! 981: struct recursion_info *prevrec; /* Previous recursion record (or NULL) */
! 982: int group_num; /* Number of group that was called */
! 983: const uschar *after_call; /* "Return value": points after the call in the expr */
! 984: USPTR save_start; /* Old value of mstart */
! 985: int *offset_save; /* Pointer to start of saved offsets */
! 986: int saved_max; /* Number of saved offsets */
! 987: } recursion_info;
! 988:
! 989: /* Structure for building a chain of data for holding the values of the subject
! 990: pointer at the start of each subpattern, so as to detect when an empty string
! 991: has been matched by a subpattern - to break infinite loops. */
! 992:
! 993: typedef struct eptrblock {
! 994: struct eptrblock *epb_prev;
! 995: USPTR epb_saved_eptr;
! 996: } eptrblock;
! 997:
! 998:
! 999: /* Structure for passing "static" information around between the functions
! 1000: doing traditional NFA matching, so that they are thread-safe. */
! 1001:
! 1002: typedef struct match_data {
! 1003: unsigned long int match_call_count; /* As it says */
! 1004: unsigned long int match_limit; /* As it says */
! 1005: unsigned long int match_limit_recursion; /* As it says */
! 1006: int *offset_vector; /* Offset vector */
! 1007: int offset_end; /* One past the end */
! 1008: int offset_max; /* The maximum usable for return data */
! 1009: int nltype; /* Newline type */
! 1010: int nllen; /* Newline string length */
! 1011: uschar nl[4]; /* Newline string when fixed */
! 1012: const uschar *lcc; /* Points to lower casing table */
! 1013: const uschar *ctypes; /* Points to table of type maps */
! 1014: BOOL offset_overflow; /* Set if too many extractions */
! 1015: BOOL notbol; /* NOTBOL flag */
! 1016: BOOL noteol; /* NOTEOL flag */
! 1017: BOOL utf8; /* UTF8 flag */
! 1018: BOOL jscript_compat; /* JAVASCRIPT_COMPAT flag */
! 1019: BOOL endonly; /* Dollar not before final \n */
! 1020: BOOL notempty; /* Empty string match not wanted */
! 1021: BOOL partial; /* PARTIAL flag */
! 1022: BOOL hitend; /* Hit the end of the subject at some point */
! 1023: BOOL bsr_anycrlf; /* \R is just any CRLF, not full Unicode */
! 1024: const uschar *start_code; /* For use when recursing */
! 1025: USPTR start_subject; /* Start of the subject string */
! 1026: USPTR end_subject; /* End of the subject string */
! 1027: USPTR start_match_ptr; /* Start of matched string */
! 1028: USPTR end_match_ptr; /* Subject position at end match */
! 1029: int end_offset_top; /* Highwater mark at end of match */
! 1030: int capture_last; /* Most recent capture number */
! 1031: int start_offset; /* The start offset value */
! 1032: eptrblock *eptrchain; /* Chain of eptrblocks for tail recursions */
! 1033: int eptrn; /* Next free eptrblock */
! 1034: recursion_info *recursive; /* Linked list of recursion data */
! 1035: void *callout_data; /* To pass back to callouts */
! 1036: } match_data;
! 1037:
! 1038: /* A similar structure is used for the same purpose by the DFA matching
! 1039: functions. */
! 1040:
! 1041: typedef struct dfa_match_data {
! 1042: const uschar *start_code; /* Start of the compiled pattern */
! 1043: const uschar *start_subject; /* Start of the subject string */
! 1044: const uschar *end_subject; /* End of subject string */
! 1045: const uschar *tables; /* Character tables */
! 1046: int moptions; /* Match options */
! 1047: int poptions; /* Pattern options */
! 1048: int nltype; /* Newline type */
! 1049: int nllen; /* Newline string length */
! 1050: uschar nl[4]; /* Newline string when fixed */
! 1051: void *callout_data; /* To pass back to callouts */
! 1052: } dfa_match_data;
! 1053:
! 1054: /* Bit definitions for entries in the pcre_ctypes table. */
! 1055:
! 1056: #define ctype_space 0x01
! 1057: #define ctype_letter 0x02
! 1058: #define ctype_digit 0x04
! 1059: #define ctype_xdigit 0x08
! 1060: #define ctype_word 0x10 /* alphanumeric or '_' */
! 1061: #define ctype_meta 0x80 /* regexp meta char or zero (end pattern) */
! 1062:
! 1063: /* Offsets for the bitmap tables in pcre_cbits. Each table contains a set
! 1064: of bits for a class map. Some classes are built by combining these tables. */
! 1065:
! 1066: #define cbit_space 0 /* [:space:] or \s */
! 1067: #define cbit_xdigit 32 /* [:xdigit:] */
! 1068: #define cbit_digit 64 /* [:digit:] or \d */
! 1069: #define cbit_upper 96 /* [:upper:] */
! 1070: #define cbit_lower 128 /* [:lower:] */
! 1071: #define cbit_word 160 /* [:word:] or \w */
! 1072: #define cbit_graph 192 /* [:graph:] */
! 1073: #define cbit_print 224 /* [:print:] */
! 1074: #define cbit_punct 256 /* [:punct:] */
! 1075: #define cbit_cntrl 288 /* [:cntrl:] */
! 1076: #define cbit_length 320 /* Length of the cbits table */
! 1077:
! 1078: /* Offsets of the various tables from the base tables pointer, and
! 1079: total length. */
! 1080:
! 1081: #define lcc_offset 0
! 1082: #define fcc_offset 256
! 1083: #define cbits_offset 512
! 1084: #define ctypes_offset (cbits_offset + cbit_length)
! 1085: #define tables_length (ctypes_offset + 256)
! 1086:
! 1087: /* Layout of the UCP type table that translates property names into types and
! 1088: codes. Each entry used to point directly to a name, but to reduce the number of
! 1089: relocations in shared libraries, it now has an offset into a single string
! 1090: instead. */
! 1091:
! 1092: typedef struct {
! 1093: pcre_uint16 name_offset;
! 1094: pcre_uint16 type;
! 1095: pcre_uint16 value;
! 1096: } ucp_type_table;
! 1097:
! 1098:
! 1099: /* Internal shared data tables. These are tables that are used by more than one
! 1100: of the exported public functions. They have to be "external" in the C sense,
! 1101: but are not part of the PCRE public API. The data for these tables is in the
! 1102: pcre_tables.c module. */
! 1103:
! 1104: extern const int _pcre_utf8_table1[];
! 1105: extern const int _pcre_utf8_table2[];
! 1106: extern const int _pcre_utf8_table3[];
! 1107: extern const uschar _pcre_utf8_table4[];
! 1108:
! 1109: extern const int _pcre_utf8_table1_size;
! 1110:
! 1111: extern const char _pcre_utt_names[];
! 1112: extern const ucp_type_table _pcre_utt[];
! 1113: extern const int _pcre_utt_size;
! 1114:
! 1115: #ifdef __cplusplus
! 1116: extern "C" const uschar _pcre_default_tables[];
! 1117: #else
! 1118: extern const uschar _pcre_default_tables[];
! 1119: #endif
! 1120:
! 1121: extern const uschar _pcre_OP_lengths[];
! 1122:
! 1123:
! 1124: /* Internal shared functions. These are functions that are used by more than
! 1125: one of the exported public functions. They have to be "external" in the C
! 1126: sense, but are not part of the PCRE public API. */
! 1127:
! 1128: extern BOOL _pcre_is_newline(const uschar *, int, const uschar *,
! 1129: int *, BOOL);
! 1130: extern int _pcre_ord2utf8(int, uschar *);
! 1131: extern real_pcre *_pcre_try_flipped(const real_pcre *, real_pcre *,
! 1132: const pcre_study_data *, pcre_study_data *);
! 1133: extern int _pcre_ucp_findprop(const unsigned int, int *, int *);
! 1134: extern unsigned int _pcre_ucp_othercase(const unsigned int);
! 1135: extern int _pcre_valid_utf8(const uschar *, int);
! 1136: extern BOOL _pcre_was_newline(const uschar *, int, const uschar *,
! 1137: int *, BOOL);
! 1138: extern BOOL _pcre_xclass(int, const uschar *);
! 1139:
! 1140: #endif
! 1141:
! 1142: /* 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