embedaddon/pcre/pcre_internal.h - view

File: [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre / pcre_internal.h
Revision 1.1.1.5 (vendor branch): download - view: text, annotated - select for diffs - revision graph
Sun Jun 15 19:46:03 2014 UTC (10 years ago) by misho
Branches: pcre, MAIN
CVS tags: v8_34, HEAD

pcre 8.34

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