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

Diff of /code/trunk/pcre_internal.h

Parent Directory | Revision Log | View Patch Patch

-revision 351 by ph10,
Fri Jul  4 18:27:16 2008 UTC
+revision 1057 by chpe,
Tue Oct 16 15:53:45 2012 UTC
 Line 7
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2008 University of Cambridge
+            Copyright (c) 1997-2012 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 40 
 POSSIBILITY OF SUCH DAMAGE.
  /* This header contains definitions that are shared between the different
  modules, but which are not relevant to the exported API. This includes some
- functions whose names all begin with "_pcre_". */
+ functions whose names all begin with "_pcre_", "_pcre16_" or "_pcre32_"
+ depending on the PRIV macro. */
  #ifndef PCRE_INTERNAL_H
  #define PCRE_INTERNAL_H
- /* Define DEBUG to get debugging output on stdout. */
+ /* Define PCRE_DEBUG to get debugging output on stdout. */
  #if 0
- #define DEBUG
+ #define PCRE_DEBUG
+ #endif
+ /* PCRE is compiled as an 8 bit library if it is not requested otherwise. */
+ #if !defined COMPILE_PCRE16 && ! defined COMPILE_PCRE32
+ #define COMPILE_PCRE8
+ #endif
+ /* If SUPPORT_UCP is defined, SUPPORT_UTF must also be defined. The
+ "configure" script ensures this, but not everybody uses "configure". */
+ #if defined SUPPORT_UCP && !(defined SUPPORT_UTF)
+ #define SUPPORT_UTF 1
+ #endif
+ /* We define SUPPORT_UTF if SUPPORT_UTF8 is enabled for compatibility
+ reasons with existing code. */
+ #if defined SUPPORT_UTF8 && !(defined SUPPORT_UTF)
+ #define SUPPORT_UTF 1
+ #endif
+ /* Fixme: SUPPORT_UTF8 should be eventually disappear from the code.
+ Until then we define it if SUPPORT_UTF is defined. */
+ #if defined SUPPORT_UTF && !(defined SUPPORT_UTF8)
+ #define SUPPORT_UTF8 1
+ #endif
+ /* We do not support both EBCDIC and UTF-8/16/32 at the same time. The "configure"
+ script prevents both being selected, but not everybody uses "configure". */
+ #if defined EBCDIC && defined SUPPORT_UTF
+ #error The use of both EBCDIC and SUPPORT_UTF is not supported.
  #endif
  /* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
-Line 60 
 It turns out that the Mac Debugging.h he
+Line 94 
 It turns out that the Mac Debugging.h he
  be absolutely sure we get our version. */
  #undef DPRINTF
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  #define DPRINTF(p) printf p
  #else
  #define DPRINTF(p) /* Nothing */
-Line 72 
 setjmp and stdarg are used is when NO_RE
+Line 106 
 setjmp and stdarg are used is when NO_RE
  #include <ctype.h>
  #include <limits.h>
- #include <setjmp.h>
- #include <stdarg.h>
  #include <stddef.h>
  #include <stdio.h>
  #include <stdlib.h>
-Line 132 
 PCRE_EXP_DATA_DEFN only if they are not
+Line 164 
 PCRE_EXP_DATA_DEFN only if they are not
  #  endif
  #endif
- /* We need to have types that specify unsigned 16-bit and 32-bit integers. We
+ /* When compiling with the MSVC compiler, it is sometimes necessary to include
+ a "calling convention" before exported function names. (This is secondhand
+ information; I know nothing about MSVC myself). For example, something like
+   void __cdecl function(....)
+ might be needed. In order so make this easy, all the exported functions have
+ PCRE_CALL_CONVENTION just before their names. It is rarely needed; if not
+ set, we ensure here that it has no effect. */
+ #ifndef PCRE_CALL_CONVENTION
+ #define PCRE_CALL_CONVENTION
+ #endif
+ /* We need to have types that specify unsigned 8, 16 and 32-bit integers. We
  cannot determine these outside the compilation (e.g. by running a program as
  part of "configure") because PCRE is often cross-compiled for use on other
  systems. Instead we make use of the maximum sizes that are available at
  preprocessor time in standard C environments. */
+ typedef unsigned char pcre_uint8;
  #if USHRT_MAX == 65535
    typedef unsigned short pcre_uint16;
    typedef short pcre_int16;
-Line 158 
 preprocessor time in standard C environm
+Line 206 
 preprocessor time in standard C environm
    #error Cannot determine a type for 32-bit unsigned integers
  #endif
+ /* When checking for integer overflow in pcre_compile(), we need to handle
+ large integers. If a 64-bit integer type is available, we can use that.
+ Otherwise we have to cast to double, which of course requires floating point
+ arithmetic. Handle this by defining a macro for the appropriate type. If
+ stdint.h is available, include it; it may define INT64_MAX. Systems that do not
+ have stdint.h (e.g. Solaris) may have inttypes.h. The macro int64_t may be set
+ by "configure". */
+ #if HAVE_STDINT_H
+ #include <stdint.h>
+ #elif HAVE_INTTYPES_H
+ #include <inttypes.h>
+ #endif
+ #if defined INT64_MAX || defined int64_t
+ #define INT64_OR_DOUBLE int64_t
+ #else
+ #define INT64_OR_DOUBLE double
+ #endif
  /* All character handling must be done as unsigned characters. Otherwise there
  are problems with top-bit-set characters and functions such as isspace().
- However, we leave the interface to the outside world as char *, because that
+ However, we leave the interface to the outside world as char * or short *,
- should make things easier for callers. We define a short type for unsigned char
+ because that should make things easier for callers. This character type is
- to save lots of typing. I tried "uchar", but it causes problems on Digital
+ called pcre_uchar.
- Unix, where it is defined in sys/types, so use "uschar" instead. */
+ The IN_UCHARS macro multiply its argument with the byte size of the current
+ pcre_uchar type. Useful for memcpy and such operations, whose require the
+ byte size of their input/output buffers.
+ The MAX_255 macro checks whether its pcre_uchar input is less than 256.
+ The TABLE_GET macro is designed for accessing elements of tables whose contain
+ exactly 256 items. When the character is able to contain more than 256
+ items, some check is needed before accessing these tables.
+ */
+ #if defined COMPILE_PCRE8
+ typedef unsigned char pcre_uchar;
+ #define IN_UCHARS(x) (x)
+ #define MAX_255(c) 1
+ #define TABLE_GET(c, table, default) ((table)[c])
+ #elif defined COMPILE_PCRE16
+ #if USHRT_MAX != 65535
+ /* This is a warning message. Change PCRE_UCHAR16 to a 16 bit data type in
+ pcre.h(.in) and disable (comment out) this message. */
+ #error Warning: PCRE_UCHAR16 is not a 16 bit data type.
+ #endif
- typedef unsigned char uschar;
+ typedef pcre_uint16 pcre_uchar;
+ #define UCHAR_SHIFT (1)
+ #define IN_UCHARS(x) ((x) << UCHAR_SHIFT)
+ #define MAX_255(c) ((c) <= 255u)
+ #define TABLE_GET(c, table, default) (MAX_255(c)? ((table)[c]):(default))
+ #elif defined COMPILE_PCRE32
+ typedef pcre_uint32 pcre_uchar;
+ #define UCHAR_SHIFT (2)
+ #define IN_UCHARS(x) ((x) << UCHAR_SHIFT)
+ #define MAX_255(c) ((c) <= 255u)
+ #define TABLE_GET(c, table, default) (MAX_255(c)? ((table)[c]):(default))
+ /* Assert that pcre_uchar32 is a 32-bit type */
+ typedef int __assert_pcre_uchar32_size[sizeof(pcre_uchar) == 4 ? 1 : -1];
+ #else
+ #error Unsupported compiling mode
+ #endif /* COMPILE_PCRE[8|16|32] */
  /* This is an unsigned int value that no character can ever have. UTF-8
  characters only go up to 0x7fffffff (though Unicode doesn't go beyond
-Line 188 
 start/end of string field names are. */
+Line 300 
 start/end of string field names are. */
  #define IS_NEWLINE(p) \
    ((NLBLOCK->nltype != NLTYPE_FIXED)? \
      ((p) < NLBLOCK->PSEND && \
-      _pcre_is_newline((p), NLBLOCK->nltype, NLBLOCK->PSEND, &(NLBLOCK->nllen),\
+      PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \
-        utf8)) \
+        &(NLBLOCK->nllen), utf)) \
      : \
      ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \
       (p)[0] == NLBLOCK->nl[0] && \
-Line 202 
 start/end of string field names are. */
+Line 314 
 start/end of string field names are. */
  #define WAS_NEWLINE(p) \
    ((NLBLOCK->nltype != NLTYPE_FIXED)? \
      ((p) > NLBLOCK->PSSTART && \
-      _pcre_was_newline((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \
+      PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \
-        &(NLBLOCK->nllen), utf8)) \
+        &(NLBLOCK->nllen), utf)) \
      : \
      ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \
       (p)[-NLBLOCK->nllen] == NLBLOCK->nl[0] && \
-Line 221 
 used for the external interface and appe
+Line 333 
 used for the external interface and appe
  must begin with PCRE_. */
  #ifdef CUSTOM_SUBJECT_PTR
- #define PCRE_SPTR CUSTOM_SUBJECT_PTR
+ #define PCRE_PUCHAR CUSTOM_SUBJECT_PTR
- #define USPTR CUSTOM_SUBJECT_PTR
  #else
- #define PCRE_SPTR const char *
+ #define PCRE_PUCHAR const pcre_uchar *
- #define USPTR const unsigned char *
  #endif
  /* Include the public PCRE header and the definitions of UCP character property
  values. */
-Line 297 
 The macros are controlled by the value o
+Line 405 
 The macros are controlled by the value o
  the config.h file, but can be overridden by using -D on the command line. This
  is automated on Unix systems via the "configure" command. */
+ #if defined COMPILE_PCRE8
  #if LINK_SIZE == 2
  #define PUT(a,n,d)   \
-Line 333 
 is automated on Unix systems via the "co
+Line 443 
 is automated on Unix systems via the "co
  #define GET(a,n) \
    (((a)[n] << 24) | ((a)[(n)+1] << 16) | ((a)[(n)+2] << 8) | (a)[(n)+3])
- #define MAX_PATTERN_SIZE (1 << 30)   /* Keep it positive */
+ /* Keep it positive */
+ #define MAX_PATTERN_SIZE (1 << 30)
+ #else
+ #error LINK_SIZE must be either 2, 3, or 4
+ #endif
+ #elif defined COMPILE_PCRE16
+ #if LINK_SIZE == 2
+ /* Redefine LINK_SIZE as a multiple of sizeof(pcre_uchar) */
+ #undef LINK_SIZE
+ #define LINK_SIZE 1
+ #define PUT(a,n,d)   \
+   (a[n] = (d))
+ #define GET(a,n) \
+   (a[n])
+ #define MAX_PATTERN_SIZE (1 << 16)
+ #elif LINK_SIZE == 3 || LINK_SIZE == 4
+ /* Redefine LINK_SIZE as a multiple of sizeof(pcre_uchar) */
+ #undef LINK_SIZE
+ #define LINK_SIZE 2
+ #define PUT(a,n,d)   \
+   (a[n] = (d) >> 16), \
+   (a[(n)+1] = (d) & 65535)
+ #define GET(a,n) \
+   (((a)[n] << 16) | (a)[(n)+1])
+ /* Keep it positive */
+ #define MAX_PATTERN_SIZE (1 << 30)
  #else
  #error LINK_SIZE must be either 2, 3, or 4
  #endif
+ #elif defined COMPILE_PCRE32
+ /* Only supported LINK_SIZE is 4 */
+ /* Redefine LINK_SIZE as a multiple of sizeof(pcre_uchar) */
+ #undef LINK_SIZE
+ #define LINK_SIZE 1
+ #define PUT(a,n,d)   \
+   (a[n] = (d))
+ #define GET(a,n) \
+   (a[n])
+ /* Keep it positive */
+ #define MAX_PATTERN_SIZE (1 << 30)
+ #else
+ #error Unsupported compiling mode
+ #endif /* COMPILE_PCRE[8|16|32] */
  /* Convenience macro defined in terms of the others */
-Line 350 
 is automated on Unix systems via the "co
+Line 515 
 is automated on Unix systems via the "co
  offsets changes. There are used for repeat counts and for other things such as
  capturing parenthesis numbers in back references. */
+ #if defined COMPILE_PCRE8
+ #define IMM2_SIZE 2
  #define PUT2(a,n,d)   \
    a[n] = (d) >> 8; \
    a[(n)+1] = (d) & 255
-Line 357 
 capturing parenthesis numbers in back re
+Line 526 
 capturing parenthesis numbers in back re
  #define GET2(a,n) \
    (((a)[n] << 8) | (a)[(n)+1])
- #define PUT2INC(a,n,d)  PUT2(a,n,d), a += 2
+ #elif defined COMPILE_PCRE16
+ #define IMM2_SIZE 1
- /* When UTF-8 encoding is being used, a character is no longer just a single
+ #define PUT2(a,n,d)   \
- byte. The macros for character handling generate simple sequences when used in
+    a[n] = d
- byte-mode, and more complicated ones for UTF-8 characters. BACKCHAR should
- never be called in byte mode. To make sure it can never even appear when UTF-8
+ #define GET2(a,n) \
- support is omitted, we don't even define it. */
+    a[n]
+ #elif defined COMPILE_PCRE32
+ #define IMM2_SIZE 1
- #ifndef SUPPORT_UTF8
+ #define PUT2(a,n,d)   \
- #define NEXTCHAR(p) p++;
+    a[n] = d
+ #define GET2(a,n) \
+    a[n]
+ #else
+ #error Unsupported compiling mode
+ #endif /* COMPILE_PCRE[8|16|32] */
+ #define PUT2INC(a,n,d)  PUT2(a,n,d), a += IMM2_SIZE
+ /* The maximum length of a MARK name is currently one data unit; it may be
+ changed in future to be a fixed number of bytes or to depend on LINK_SIZE. */
+ #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+ #define MAX_MARK ((1u << 16) - 1)
+ #else
+ #define MAX_MARK ((1u << 8) - 1)
+ #endif
+ /* When UTF encoding is being used, a character is no longer just a single
+ byte. The macros for character handling generate simple sequences when used in
+ character-mode, and more complicated ones for UTF characters. GETCHARLENTEST
+ and other macros are not used when UTF is not supported, so they are not
+ defined. To make sure they can never even appear when UTF support is omitted,
+ we don't even define them. */
+ #ifndef SUPPORT_UTF
+ /* #define MAX_VALUE_FOR_SINGLE_CHAR */
+ /* #define HAS_EXTRALEN(c) */
+ /* #define GET_EXTRALEN(c) */
+ /* #define NOT_FIRSTCHAR(c) */
  #define GETCHAR(c, eptr) c = *eptr;
  #define GETCHARTEST(c, eptr) c = *eptr;
  #define GETCHARINC(c, eptr) c = *eptr++;
  #define GETCHARINCTEST(c, eptr) c = *eptr++;
  #define GETCHARLEN(c, eptr, len) c = *eptr;
+ /* #define GETCHARLENTEST(c, eptr, len) */
  /* #define BACKCHAR(eptr) */
+ /* #define FORWARDCHAR(eptr) */
+ /* #define ACROSSCHAR(condition, eptr, action) */
+ #else   /* SUPPORT_UTF */
+ #if defined COMPILE_PCRE8
+ /* These macros were originally written in the form of loops that used data
+ from the tables whose names start with PRIV(utf8_table). They were rewritten by
+ a user so as not to use loops, because in some environments this gives a
+ significant performance advantage, and it seems never to do any harm. */
+ /* Tells the biggest code point which can be encoded as a single character. */
+ #define MAX_VALUE_FOR_SINGLE_CHAR 127
- #else   /* SUPPORT_UTF8 */
+ /* Tests whether the code point needs extra characters to decode. */
- /* Advance a character pointer one byte in non-UTF-8 mode and by one character
+ #define HAS_EXTRALEN(c) ((c) >= 0xc0)
- in UTF-8 mode. */
- #define NEXTCHAR(p) \
+ /* Returns with the additional number of characters if IS_MULTICHAR(c) is TRUE.
-   p++; \
+ Otherwise it has an undefined behaviour. */
-   if (utf8) { while((*p & 0xc0) == 0x80) p++; }
+ #define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3f])
+ /* Returns TRUE, if the given character is not the first character
+ of a UTF sequence. */
+ #define NOT_FIRSTCHAR(c) (((c) & 0xc0) == 0x80)
+ /* Base macro to pick up the remaining bytes of a UTF-8 character, not
+ advancing the pointer. */
+ #define GETUTF8(c, eptr) \
+     { \
+     if ((c & 0x20) == 0) \
+       c = ((c & 0x1f) << 6) | (eptr[1] & 0x3f); \
+     else if ((c & 0x10) == 0) \
+       c = ((c & 0x0f) << 12) | ((eptr[1] & 0x3f) << 6) | (eptr[2] & 0x3f); \
+     else if ((c & 0x08) == 0) \
+       c = ((c & 0x07) << 18) | ((eptr[1] & 0x3f) << 12) | \
+       ((eptr[2] & 0x3f) << 6) | (eptr[3] & 0x3f); \
+     else if ((c & 0x04) == 0) \
+       c = ((c & 0x03) << 24) | ((eptr[1] & 0x3f) << 18) | \
+           ((eptr[2] & 0x3f) << 12) | ((eptr[3] & 0x3f) << 6) | \
+           (eptr[4] & 0x3f); \
+     else \
+       c = ((c & 0x01) << 30) | ((eptr[1] & 0x3f) << 24) | \
+           ((eptr[2] & 0x3f) << 18) | ((eptr[3] & 0x3f) << 12) | \
+           ((eptr[4] & 0x3f) << 6) | (eptr[5] & 0x3f); \
+     }
  /* Get the next UTF-8 character, not advancing the pointer. This is called when
  we know we are in UTF-8 mode. */
  #define GETCHAR(c, eptr) \
    c = *eptr; \
-   if (c >= 0xc0) \
+   if (c >= 0xc0) GETUTF8(c, eptr);
-     { \
-     int gcii; \
-     int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
-     int gcss = 6*gcaa; \
-     c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
-     for (gcii = 1; gcii <= gcaa; gcii++) \
-       { \
-       gcss -= 6; \
-       c |= (eptr[gcii] & 0x3f) << gcss; \
-       } \
-     }
  /* Get the next UTF-8 character, testing for UTF-8 mode, and not advancing the
  pointer. */
  #define GETCHARTEST(c, eptr) \
    c = *eptr; \
-   if (utf8 && c >= 0xc0) \
+   if (utf && c >= 0xc0) GETUTF8(c, eptr);
+ /* Base macro to pick up the remaining bytes of a UTF-8 character, advancing
+ the pointer. */
+ #define GETUTF8INC(c, eptr) \
      { \
-     int gcii; \
+     if ((c & 0x20) == 0) \
-     int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+       c = ((c & 0x1f) << 6) | (*eptr++ & 0x3f); \
-     int gcss = 6*gcaa; \
+     else if ((c & 0x10) == 0) \
-     c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
+       { \
-     for (gcii = 1; gcii <= gcaa; gcii++) \
+       c = ((c & 0x0f) << 12) | ((*eptr & 0x3f) << 6) | (eptr[1] & 0x3f); \
+       eptr += 2; \
+       } \
+     else if ((c & 0x08) == 0) \
+       { \
+       c = ((c & 0x07) << 18) | ((*eptr & 0x3f) << 12) | \
+           ((eptr[1] & 0x3f) << 6) | (eptr[2] & 0x3f); \
+       eptr += 3; \
+       } \
+     else if ((c & 0x04) == 0) \
        { \
-       gcss -= 6; \
+       c = ((c & 0x03) << 24) | ((*eptr & 0x3f) << 18) | \
-       c |= (eptr[gcii] & 0x3f) << gcss; \
+           ((eptr[1] & 0x3f) << 12) | ((eptr[2] & 0x3f) << 6) | \
+           (eptr[3] & 0x3f); \
+       eptr += 4; \
+       } \
+     else \
+       { \
+       c = ((c & 0x01) << 30) | ((*eptr & 0x3f) << 24) | \
+           ((eptr[1] & 0x3f) << 18) | ((eptr[2] & 0x3f) << 12) | \
+           ((eptr[3] & 0x3f) << 6) | (eptr[4] & 0x3f); \
+       eptr += 5; \
        } \
      }
-Line 425 
 know we are in UTF-8 mode. */
+Line 686 
 know we are in UTF-8 mode. */
  #define GETCHARINC(c, eptr) \
    c = *eptr++; \
-   if (c >= 0xc0) \
+   if (c >= 0xc0) GETUTF8INC(c, eptr);
-     { \
-     int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
-     int gcss = 6*gcaa; \
-     c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
-     while (gcaa-- > 0) \
-       { \
-       gcss -= 6; \
-       c |= (*eptr++ & 0x3f) << gcss; \
-       } \
-     }
- /* Get the next character, testing for UTF-8 mode, and advancing the pointer */
+ /* Get the next character, testing for UTF-8 mode, and advancing the pointer.
+ This is called when we don't know if we are in UTF-8 mode. */
  #define GETCHARINCTEST(c, eptr) \
    c = *eptr++; \
-   if (utf8 && c >= 0xc0) \
+   if (utf && c >= 0xc0) GETUTF8INC(c, eptr);
+ /* Base macro to pick up the remaining bytes of a UTF-8 character, not
+ advancing the pointer, incrementing the length. */
+ #define GETUTF8LEN(c, eptr, len) \
      { \
-     int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+     if ((c & 0x20) == 0) \
-     int gcss = 6*gcaa; \
-     c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
-     while (gcaa-- > 0) \
        { \
-       gcss -= 6; \
+       c = ((c & 0x1f) << 6) | (eptr[1] & 0x3f); \
-       c |= (*eptr++ & 0x3f) << gcss; \
+       len++; \
+       } \
+     else if ((c & 0x10)  == 0) \
+       { \
+       c = ((c & 0x0f) << 12) | ((eptr[1] & 0x3f) << 6) | (eptr[2] & 0x3f); \
+       len += 2; \
+       } \
+     else if ((c & 0x08)  == 0) \
+       {\
+       c = ((c & 0x07) << 18) | ((eptr[1] & 0x3f) << 12) | \
+           ((eptr[2] & 0x3f) << 6) | (eptr[3] & 0x3f); \
+       len += 3; \
+       } \
+     else if ((c & 0x04)  == 0) \
+       { \
+       c = ((c & 0x03) << 24) | ((eptr[1] & 0x3f) << 18) | \
+           ((eptr[2] & 0x3f) << 12) | ((eptr[3] & 0x3f) << 6) | \
+           (eptr[4] & 0x3f); \
+       len += 4; \
+       } \
+     else \
+       {\
+       c = ((c & 0x01) << 30) | ((eptr[1] & 0x3f) << 24) | \
+           ((eptr[2] & 0x3f) << 18) | ((eptr[3] & 0x3f) << 12) | \
+           ((eptr[4] & 0x3f) << 6) | (eptr[5] & 0x3f); \
+       len += 5; \
        } \
      }
-Line 458 
 if there are extra bytes. This is called
+Line 737 
 if there are extra bytes. This is called
  #define GETCHARLEN(c, eptr, len) \
    c = *eptr; \
-   if (c >= 0xc0) \
+   if (c >= 0xc0) GETUTF8LEN(c, eptr, len);
-     { \
-     int gcii; \
+ /* Get the next UTF-8 character, testing for UTF-8 mode, not advancing the
-     int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+ pointer, incrementing length if there are extra bytes. This is called when we
-     int gcss = 6*gcaa; \
+ do not know if we are in UTF-8 mode. */
-     c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
-     for (gcii = 1; gcii <= gcaa; gcii++) \
+ #define GETCHARLENTEST(c, eptr, len) \
-       { \
+   c = *eptr; \
-       gcss -= 6; \
+   if (utf && c >= 0xc0) GETUTF8LEN(c, eptr, len);
-       c |= (eptr[gcii] & 0x3f) << gcss; \
-       } \
-     len += gcaa; \
-     }
  /* If the pointer is not at the start of a character, move it back until
  it is. This is called only in UTF-8 mode - we don't put a test within the macro
-Line 478 
 because almost all calls are already wit
+Line 753 
 because almost all calls are already wit
  #define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--
- #endif
+ /* Same as above, just in the other direction. */
+ #define FORWARDCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr++
+ /* Same as above, but it allows a fully customizable form. */
+ #define ACROSSCHAR(condition, eptr, action) \
+   while((condition) && ((eptr) & 0xc0) == 0x80) action
- /* In case there is no definition of offsetof() provided - though any proper
+ #elif defined COMPILE_PCRE16
- Standard C system should have one. */
- #ifndef offsetof
+ /* Tells the biggest code point which can be encoded as a single character. */
- #define offsetof(p_type,field) ((size_t)&(((p_type *)0)->field))
- #endif
+ #define MAX_VALUE_FOR_SINGLE_CHAR 65535
+ /* Tests whether the code point needs extra characters to decode. */
+ #define HAS_EXTRALEN(c) (((c) & 0xfc00) == 0xd800)
+ /* Returns with the additional number of characters if IS_MULTICHAR(c) is TRUE.
+ Otherwise it has an undefined behaviour. */
+ #define GET_EXTRALEN(c) 1
+ /* Returns TRUE, if the given character is not the first character
+ of a UTF sequence. */
+ #define NOT_FIRSTCHAR(c) (((c) & 0xfc00) == 0xdc00)
+ /* Base macro to pick up the low surrogate of a UTF-16 character, not
+ advancing the pointer. */
+ #define GETUTF16(c, eptr) \
+    { c = (((c & 0x3ff) << 10) | (eptr[1] & 0x3ff)) + 0x10000; }
+ /* Get the next UTF-16 character, not advancing the pointer. This is called when
+ we know we are in UTF-16 mode. */
+ #define GETCHAR(c, eptr) \
+   c = *eptr; \
+   if ((c & 0xfc00) == 0xd800) GETUTF16(c, eptr);
+ /* Get the next UTF-16 character, testing for UTF-16 mode, and not advancing the
+ pointer. */
+ #define GETCHARTEST(c, eptr) \
+   c = *eptr; \
+   if (utf && (c & 0xfc00) == 0xd800) GETUTF16(c, eptr);
+ /* Base macro to pick up the low surrogate of a UTF-16 character, advancing
+ the pointer. */
+ #define GETUTF16INC(c, eptr) \
+    { c = (((c & 0x3ff) << 10) | (*eptr++ & 0x3ff)) + 0x10000; }
+ /* Get the next UTF-16 character, advancing the pointer. This is called when we
+ know we are in UTF-16 mode. */
+ #define GETCHARINC(c, eptr) \
+   c = *eptr++; \
+   if ((c & 0xfc00) == 0xd800) GETUTF16INC(c, eptr);
+ /* Get the next character, testing for UTF-16 mode, and advancing the pointer.
+ This is called when we don't know if we are in UTF-16 mode. */
+ #define GETCHARINCTEST(c, eptr) \
+   c = *eptr++; \
+   if (utf && (c & 0xfc00) == 0xd800) GETUTF16INC(c, eptr);
+ /* Base macro to pick up the low surrogate of a UTF-16 character, not
+ advancing the pointer, incrementing the length. */
+ #define GETUTF16LEN(c, eptr, len) \
+    { c = (((c & 0x3ff) << 10) | (eptr[1] & 0x3ff)) + 0x10000; len++; }
+ /* Get the next UTF-16 character, not advancing the pointer, incrementing
+ length if there is a low surrogate. This is called when we know we are in
+ UTF-16 mode. */
+ #define GETCHARLEN(c, eptr, len) \
+   c = *eptr; \
+   if ((c & 0xfc00) == 0xd800) GETUTF16LEN(c, eptr, len);
+ /* Get the next UTF-816character, testing for UTF-16 mode, not advancing the
+ pointer, incrementing length if there is a low surrogate. This is called when
+ we do not know if we are in UTF-16 mode. */
+ #define GETCHARLENTEST(c, eptr, len) \
+   c = *eptr; \
+   if (utf && (c & 0xfc00) == 0xd800) GETUTF16LEN(c, eptr, len);
+ /* If the pointer is not at the start of a character, move it back until
+ it is. This is called only in UTF-16 mode - we don't put a test within the
+ macro because almost all calls are already within a block of UTF-16 only
+ code. */
+ #define BACKCHAR(eptr) if ((*eptr & 0xfc00) == 0xdc00) eptr--
+ /* Same as above, just in the other direction. */
+ #define FORWARDCHAR(eptr) if ((*eptr & 0xfc00) == 0xdc00) eptr++
+ /* Same as above, but it allows a fully customizable form. */
+ #define ACROSSCHAR(condition, eptr, action) \
+   if ((condition) && ((eptr) & 0xfc00) == 0xdc00) action
+ #elif defined COMPILE_PCRE32
+ /* These are unnecessary for the 32-bit library */
+ #undef MAX_VALUE_FOR_SINGLE_CHAR
+ #undef HAS_EXTRALEN
+ #undef GET_EXTRALEN
+ #undef NOT_FIRSTCHAR
+ /* Get the next UTF-32 character, not advancing the pointer. This is called when
+ we know we are in UTF-32 mode. */
+ #define GETCHAR(c, eptr) \
+   c = *eptr;
+ /* Get the next UTF-32 character, testing for UTF-32 mode, and not advancing the
+ pointer. */
+ #define GETCHARTEST(c, eptr) \
+   c = *eptr;
+ /* Get the next UTF-32 character, advancing the pointer. This is called when we
+ know we are in UTF-32 mode. */
+ #define GETCHARINC(c, eptr) \
+   c = *eptr++;
+ /* Get the next character, testing for UTF-32 mode, and advancing the pointer.
+ This is called when we don't know if we are in UTF-32 mode. */
+ #define GETCHARINCTEST(c, eptr) \
+   c = *eptr++;
+ /* Get the next UTF-32 character, not advancing the pointer, not incrementing
+ length (since all UTF-32 is of length 1). This is called when we know we are in
+ UTF-32 mode. */
+ #define GETCHARLEN(c, eptr, len) \
+   c = *eptr;
+ /* Get the next UTF-832character, testing for UTF-32 mode, not advancing the
+ pointer, not incrementing the length (since all UTF-32 is of length 1).
+ This is called when we do not know if we are in UTF-32 mode. */
+ #define GETCHARLENTEST(c, eptr, len) \
+   c = *eptr;
+ /* If the pointer is not at the start of a character, move it back until
+ it is. This is called only in UTF-32 mode - we don't put a test within the
+ macro because almost all calls are already within a block of UTF-32 only
+ code. */
+ #define BACKCHAR(eptr) do { } while (0)
+ /* Same as above, just in the other direction. */
+ #define FORWARDCHAR(eptr) do { } while (0)
+ /* Same as above, but it allows a fully customizable form. */
+ #define ACROSSCHAR(condition, eptr, action) do { } while (0)
+ #else
+ #error Unsupported compiling mode
+ #endif /* COMPILE_PCRE[8|16|32] */
+ #endif  /* SUPPORT_UTF */
+ /* Tests for Unicode horizontal and vertical whitespace characters must check a
+ number of different values. Using a switch statement for this generates the
+ fastest code (no loop, no memory access), and there are several places in the
+ interpreter code where this happens. In order to ensure that all the case lists
+ remain in step, we use macros so that there is only one place where the lists
+ are defined.
+ These values are also required as lists in pcre_compile.c when processing \h,
+ \H, \v and \V in a character class. The lists are defined in pcre_tables.c, but
+ macros that define the values are here so that all the definitions are
+ together. The lists must be in ascending character order, terminated by
+ NOTACHAR (which is 0xffffffff).
+ Any changes should ensure that the various macros are kept in step with each
+ other. NOTE: The values also appear in pcre_jit_compile.c. */
+ /* ------ ASCII/Unicode environments ------ */
+ #ifndef EBCDIC
+ #define HSPACE_LIST \
+   CHAR_HT, CHAR_SPACE, 0xa0, \
+x1680, 0x180e, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, \
+x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202f, 0x205f, 0x3000, \
+   NOTACHAR
+ #define HSPACE_MULTIBYTE_CASES \
+   case 0x1680:  /* OGHAM SPACE MARK */ \
+   case 0x180e:  /* MONGOLIAN VOWEL SEPARATOR */ \
+   case 0x2000:  /* EN QUAD */ \
+   case 0x2001:  /* EM QUAD */ \
+   case 0x2002:  /* EN SPACE */ \
+   case 0x2003:  /* EM SPACE */ \
+   case 0x2004:  /* THREE-PER-EM SPACE */ \
+   case 0x2005:  /* FOUR-PER-EM SPACE */ \
+   case 0x2006:  /* SIX-PER-EM SPACE */ \
+   case 0x2007:  /* FIGURE SPACE */ \
+   case 0x2008:  /* PUNCTUATION SPACE */ \
+   case 0x2009:  /* THIN SPACE */ \
+   case 0x200A:  /* HAIR SPACE */ \
+   case 0x202f:  /* NARROW NO-BREAK SPACE */ \
+   case 0x205f:  /* MEDIUM MATHEMATICAL SPACE */ \
+   case 0x3000   /* IDEOGRAPHIC SPACE */
+ #define HSPACE_BYTE_CASES \
+   case CHAR_HT: \
+   case CHAR_SPACE: \
+   case 0xa0     /* NBSP */
+ #define HSPACE_CASES \
+   HSPACE_BYTE_CASES: \
+   HSPACE_MULTIBYTE_CASES
+ #define VSPACE_LIST \
+   CHAR_LF, CHAR_VT, CHAR_FF, CHAR_CR, CHAR_NEL, 0x2028, 0x2029, NOTACHAR
+ #define VSPACE_MULTIBYTE_CASES \
+   case 0x2028:    /* LINE SEPARATOR */ \
+   case 0x2029     /* PARAGRAPH SEPARATOR */
+ #define VSPACE_BYTE_CASES \
+   case CHAR_LF: \
+   case CHAR_VT: \
+   case CHAR_FF: \
+   case CHAR_CR: \
+   case CHAR_NEL
+ #define VSPACE_CASES \
+   VSPACE_BYTE_CASES: \
+   VSPACE_MULTIBYTE_CASES
+ /* ------ EBCDIC environments ------ */
+ #else
+ #define HSPACE_LIST CHAR_HT, CHAR_SPACE
+ #define HSPACE_BYTE_CASES \
+   case CHAR_HT: \
+   case CHAR_SPACE
+ #define HSPACE_CASES HSPACE_BYTE_CASES
+ #ifdef EBCDIC_NL25
+ #define VSPACE_LIST \
+   CHAR_VT, CHAR_FF, CHAR_CR, CHAR_NEL, CHAR_LF, NOTACHAR
+ #else
+ #define VSPACE_LIST \
+   CHAR_VT, CHAR_FF, CHAR_CR, CHAR_LF, CHAR_NEL, NOTACHAR
+ #endif
+ #define VSPACE_BYTE_CASES \
+   case CHAR_LF: \
+   case CHAR_VT: \
+   case CHAR_FF: \
+   case CHAR_CR: \
+   case CHAR_NEL
+ #define VSPACE_CASES VSPACE_BYTE_CASES
+ #endif  /* EBCDIC */
+ /* ------ End of whitespace macros ------ */
- /* These are the public options that can change during matching. */
- #define PCRE_IMS (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL)
  /* Private flags containing information about the compiled regex. They used to
  live at the top end of the options word, but that got almost full, so now they
- are in a 16-bit flags word. */
+ are in a 16-bit flags word. From release 8.00, PCRE_NOPARTIAL is unused, as
+ the restrictions on partial matching have been lifted. It remains for backwards
- #define PCRE_NOPARTIAL     0x0001  /* can't use partial with this regex */
+ compatibility. */
- #define PCRE_FIRSTSET      0x0002  /* first_byte is set */
- #define PCRE_REQCHSET      0x0004  /* req_byte is set */
+ #define PCRE_MODE8         0x0001  /* compiled in 8 bit mode */
- #define PCRE_STARTLINE     0x0008  /* start after \n for multiline */
+ #define PCRE_MODE16        0x0002  /* compiled in 16 bit mode */
- #define PCRE_JCHANGED      0x0010  /* j option used in regex */
+ #define PCRE_MODE32        0x0004  /* compiled in 32 bit mode */
- #define PCRE_HASCRORLF     0x0020  /* explicit \r or \n in pattern */
+ #define PCRE_FIRSTSET      0x0010  /* first_char is set */
+ #define PCRE_FCH_CASELESS  0x0020  /* caseless first char */
+ #define PCRE_REQCHSET      0x0040  /* req_byte is set */
+ #define PCRE_RCH_CASELESS  0x0080  /* caseless requested char */
+ #define PCRE_STARTLINE     0x0100  /* start after \n for multiline */
+ #define PCRE_NOPARTIAL     0x0200  /* can't use partial with this regex */
+ #define PCRE_JCHANGED      0x0400  /* j option used in regex */
+ #define PCRE_HASCRORLF     0x0800  /* explicit \r or \n in pattern */
+ #define PCRE_HASTHEN       0x1000  /* pattern contains (*THEN) */
+ #if defined COMPILE_PCRE8
+ #define PCRE_MODE          PCRE_MODE8
+ #elif defined COMPILE_PCRE16
+ #define PCRE_MODE          PCRE_MODE16
+ #elif defined COMPILE_PCRE32
+ #define PCRE_MODE          PCRE_MODE32
+ #endif
+ #define PCRE_MODE_MASK     (PCRE_MODE8 | PCRE_MODE16 | PCRE_MODE32)
- /* Options for the "extra" block produced by pcre_study(). */
+ /* Flags for the "extra" block produced by pcre_study(). */
- #define PCRE_STUDY_MAPPED   0x01     /* a map of starting chars exists */
+ #define PCRE_STUDY_MAPPED  0x0001  /* a map of starting chars exists */
+ #define PCRE_STUDY_MINLEN  0x0002  /* a minimum length field exists */
  /* Masks for identifying the public options that are permitted at compile
  time, run time, or study time, respectively. */
-Line 514 
 time, run time, or study time, respectiv
+Line 1064 
 time, run time, or study time, respectiv
  #define PCRE_NEWLINE_BITS (PCRE_NEWLINE_CR|PCRE_NEWLINE_LF|PCRE_NEWLINE_ANY| \
                             PCRE_NEWLINE_ANYCRLF)
- #define PUBLIC_OPTIONS \
+ #define PUBLIC_COMPILE_OPTIONS \
    (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \
     PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY|PCRE_UTF8| \
     PCRE_NO_AUTO_CAPTURE|PCRE_NO_UTF8_CHECK|PCRE_AUTO_CALLOUT|PCRE_FIRSTLINE| \
     PCRE_DUPNAMES|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE| \
-    PCRE_JAVASCRIPT_COMPAT)
+    PCRE_JAVASCRIPT_COMPAT|PCRE_UCP|PCRE_NO_START_OPTIMIZE)
  #define PUBLIC_EXEC_OPTIONS \
-   (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \
+   (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NOTEMPTY_ATSTART| \
-    PCRE_PARTIAL|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)
+    PCRE_NO_UTF8_CHECK|PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT|PCRE_NEWLINE_BITS| \
+    PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE|PCRE_NO_START_OPTIMIZE)
  #define PUBLIC_DFA_EXEC_OPTIONS \
-   (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \
+   (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NOTEMPTY_ATSTART| \
-    PCRE_PARTIAL|PCRE_DFA_SHORTEST|PCRE_DFA_RESTART|PCRE_NEWLINE_BITS| \
+    PCRE_NO_UTF8_CHECK|PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT|PCRE_DFA_SHORTEST| \
-    PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)
+    PCRE_DFA_RESTART|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE| \
+    PCRE_NO_START_OPTIMIZE)
- #define PUBLIC_STUDY_OPTIONS 0   /* None defined */
+ #define PUBLIC_STUDY_OPTIONS \
+    (PCRE_STUDY_JIT_COMPILE|PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE| \
+     PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE|PCRE_STUDY_EXTRA_NEEDED)
- /* Magic number to provide a small check against being handed junk. Also used
+ /* Magic number to provide a small check against being handed junk. */
- to detect whether a pattern was compiled on a host of different endianness. */
  #define MAGIC_NUMBER  0x50435245UL   /* 'PCRE' */
+ /* This variable is used to detect a loaded regular expression
+ in different endianness. */
+ #define REVERSED_MAGIC_NUMBER  0x45524350UL   /* 'ERCP' */
  /* Negative values for the firstchar and reqchar variables */
  #define REQ_UNSET (-2)
-Line 547 
 req_byte match. */
+Line 1105 
 req_byte match. */
  #define REQ_BYTE_MAX 1000
- /* Flags added to firstbyte or reqbyte; a "non-literal" item is either a
+ /* Miscellaneous definitions. The #ifndef is to pacify compiler warnings in
- variable-length repeat, or a anything other than literal characters. */
+ environments where these macros are defined elsewhere. Unfortunately, there
+ is no way to do the same for the typedef. */
- #define REQ_CASELESS 0x0100    /* indicates caselessness */
- #define REQ_VARY     0x0200    /* reqbyte followed non-literal item */
- /* Miscellaneous definitions */
  typedef int BOOL;
+ #ifndef FALSE
  #define FALSE   0
  #define TRUE    1
+ #endif
+ /* If PCRE is to support UTF-8 on EBCDIC platforms, we cannot use normal
+ character constants like '*' because the compiler would emit their EBCDIC code,
+ which is different from their ASCII/UTF-8 code. Instead we define macros for
+ the characters so that they always use the ASCII/UTF-8 code when UTF-8 support
+ is enabled. When UTF-8 support is not enabled, the definitions use character
+ literals. Both character and string versions of each character are needed, and
+ there are some longer strings as well.
+ This means that, on EBCDIC platforms, the PCRE library can handle either
+ EBCDIC, or UTF-8, but not both. To support both in the same compiled library
+ would need different lookups depending on whether PCRE_UTF8 was set or not.
+ This would make it impossible to use characters in switch/case statements,
+ which would reduce performance. For a theoretical use (which nobody has asked
+ for) in a minority area (EBCDIC platforms), this is not sensible. Any
+ application that did need both could compile two versions of the library, using
+ macros to give the functions distinct names. */
+ #ifndef SUPPORT_UTF
+ /* UTF-8 support is not enabled; use the platform-dependent character literals
+ so that PCRE works in both ASCII and EBCDIC environments, but only in non-UTF
+ mode. Newline characters are problematic in EBCDIC. Though it has CR and LF
+ characters, a common practice has been to use its NL (0x15) character as the
+ line terminator in C-like processing environments. However, sometimes the LF
+ (0x25) character is used instead, according to this Unicode document:
+ http://unicode.org/standard/reports/tr13/tr13-5.html
+ PCRE defaults EBCDIC NL to 0x15, but has a build-time option to select 0x25
+ instead. Whichever is *not* chosen is defined as NEL.
+ In both ASCII and EBCDIC environments, CHAR_NL and CHAR_LF are synonyms for the
+ same code point. */
+ #ifdef EBCDIC
+ #ifndef EBCDIC_NL25
+ #define CHAR_NL                     '\x15'
+ #define CHAR_NEL                    '\x25'
+ #define STR_NL                      "\x15"
+ #define STR_NEL                     "\x25"
+ #else
+ #define CHAR_NL                     '\x25'
+ #define CHAR_NEL                    '\x15'
+ #define STR_NL                      "\x25"
+ #define STR_NEL                     "\x15"
+ #endif
+ #define CHAR_LF                     CHAR_NL
+ #define STR_LF                      STR_NL
+ #define CHAR_ESC                    '\047'
+ #define CHAR_DEL                    '\007'
+ #define STR_ESC                     "\047"
+ #define STR_DEL                     "\007"
+ #else  /* Not EBCDIC */
+ /* In ASCII/Unicode, linefeed is '\n' and we equate this to NL for
+ compatibility. NEL is the Unicode newline character; make sure it is
+ a positive value. */
+ #define CHAR_LF                     '\n'
+ #define CHAR_NL                     CHAR_LF
+ #define CHAR_NEL                    ((unsigned char)'\x85')
+ #define CHAR_ESC                    '\033'
+ #define CHAR_DEL                    '\177'
+ #define STR_LF                      "\n"
+ #define STR_NL                      STR_LF
+ #define STR_NEL                     "\x85"
+ #define STR_ESC                     "\033"
+ #define STR_DEL                     "\177"
+ #endif  /* EBCDIC */
+ /* The remaining definitions work in both environments. */
+ #define CHAR_HT                     '\t'
+ #define CHAR_VT                     '\v'
+ #define CHAR_FF                     '\f'
+ #define CHAR_CR                     '\r'
+ #define CHAR_BS                     '\b'
+ #define CHAR_BEL                    '\a'
+ #define CHAR_SPACE                  ' '
+ #define CHAR_EXCLAMATION_MARK       '!'
+ #define CHAR_QUOTATION_MARK         '"'
+ #define CHAR_NUMBER_SIGN            '#'
+ #define CHAR_DOLLAR_SIGN            '$'
+ #define CHAR_PERCENT_SIGN           '%'
+ #define CHAR_AMPERSAND              '&'
+ #define CHAR_APOSTROPHE             '\''
+ #define CHAR_LEFT_PARENTHESIS       '('
+ #define CHAR_RIGHT_PARENTHESIS      ')'
+ #define CHAR_ASTERISK               '*'
+ #define CHAR_PLUS                   '+'
+ #define CHAR_COMMA                  ','
+ #define CHAR_MINUS                  '-'
+ #define CHAR_DOT                    '.'
+ #define CHAR_SLASH                  '/'
+ #define CHAR_0                      '0'
+ #define CHAR_1                      '1'
+ #define CHAR_2                      '2'
+ #define CHAR_3                      '3'
+ #define CHAR_4                      '4'
+ #define CHAR_5                      '5'
+ #define CHAR_6                      '6'
+ #define CHAR_7                      '7'
+ #define CHAR_8                      '8'
+ #define CHAR_9                      '9'
+ #define CHAR_COLON                  ':'
+ #define CHAR_SEMICOLON              ';'
+ #define CHAR_LESS_THAN_SIGN         '<'
+ #define CHAR_EQUALS_SIGN            '='
+ #define CHAR_GREATER_THAN_SIGN      '>'
+ #define CHAR_QUESTION_MARK          '?'
+ #define CHAR_COMMERCIAL_AT          '@'
+ #define CHAR_A                      'A'
+ #define CHAR_B                      'B'
+ #define CHAR_C                      'C'
+ #define CHAR_D                      'D'
+ #define CHAR_E                      'E'
+ #define CHAR_F                      'F'
+ #define CHAR_G                      'G'
+ #define CHAR_H                      'H'
+ #define CHAR_I                      'I'
+ #define CHAR_J                      'J'
+ #define CHAR_K                      'K'
+ #define CHAR_L                      'L'
+ #define CHAR_M                      'M'
+ #define CHAR_N                      'N'
+ #define CHAR_O                      'O'
+ #define CHAR_P                      'P'
+ #define CHAR_Q                      'Q'
+ #define CHAR_R                      'R'
+ #define CHAR_S                      'S'
+ #define CHAR_T                      'T'
+ #define CHAR_U                      'U'
+ #define CHAR_V                      'V'
+ #define CHAR_W                      'W'
+ #define CHAR_X                      'X'
+ #define CHAR_Y                      'Y'
+ #define CHAR_Z                      'Z'
+ #define CHAR_LEFT_SQUARE_BRACKET    '['
+ #define CHAR_BACKSLASH              '\\'
+ #define CHAR_RIGHT_SQUARE_BRACKET   ']'
+ #define CHAR_CIRCUMFLEX_ACCENT      '^'
+ #define CHAR_UNDERSCORE             '_'
+ #define CHAR_GRAVE_ACCENT           '`'
+ #define CHAR_a                      'a'
+ #define CHAR_b                      'b'
+ #define CHAR_c                      'c'
+ #define CHAR_d                      'd'
+ #define CHAR_e                      'e'
+ #define CHAR_f                      'f'
+ #define CHAR_g                      'g'
+ #define CHAR_h                      'h'
+ #define CHAR_i                      'i'
+ #define CHAR_j                      'j'
+ #define CHAR_k                      'k'
+ #define CHAR_l                      'l'
+ #define CHAR_m                      'm'
+ #define CHAR_n                      'n'
+ #define CHAR_o                      'o'
+ #define CHAR_p                      'p'
+ #define CHAR_q                      'q'
+ #define CHAR_r                      'r'
+ #define CHAR_s                      's'
+ #define CHAR_t                      't'
+ #define CHAR_u                      'u'
+ #define CHAR_v                      'v'
+ #define CHAR_w                      'w'
+ #define CHAR_x                      'x'
+ #define CHAR_y                      'y'
+ #define CHAR_z                      'z'
+ #define CHAR_LEFT_CURLY_BRACKET     '{'
+ #define CHAR_VERTICAL_LINE          '|'
+ #define CHAR_RIGHT_CURLY_BRACKET    '}'
+ #define CHAR_TILDE                  '~'
+ #define STR_HT                      "\t"
+ #define STR_VT                      "\v"
+ #define STR_FF                      "\f"
+ #define STR_CR                      "\r"
+ #define STR_BS                      "\b"
+ #define STR_BEL                     "\a"
+ #define STR_SPACE                   " "
+ #define STR_EXCLAMATION_MARK        "!"
+ #define STR_QUOTATION_MARK          "\""
+ #define STR_NUMBER_SIGN             "#"
+ #define STR_DOLLAR_SIGN             "$"
+ #define STR_PERCENT_SIGN            "%"
+ #define STR_AMPERSAND               "&"
+ #define STR_APOSTROPHE              "'"
+ #define STR_LEFT_PARENTHESIS        "("
+ #define STR_RIGHT_PARENTHESIS       ")"
+ #define STR_ASTERISK                "*"
+ #define STR_PLUS                    "+"
+ #define STR_COMMA                   ","
+ #define STR_MINUS                   "-"
+ #define STR_DOT                     "."
+ #define STR_SLASH                   "/"
+ #define STR_0                       "0"
+ #define STR_1                       "1"
+ #define STR_2                       "2"
+ #define STR_3                       "3"
+ #define STR_4                       "4"
+ #define STR_5                       "5"
+ #define STR_6                       "6"
+ #define STR_7                       "7"
+ #define STR_8                       "8"
+ #define STR_9                       "9"
+ #define STR_COLON                   ":"
+ #define STR_SEMICOLON               ";"
+ #define STR_LESS_THAN_SIGN          "<"
+ #define STR_EQUALS_SIGN             "="
+ #define STR_GREATER_THAN_SIGN       ">"
+ #define STR_QUESTION_MARK           "?"
+ #define STR_COMMERCIAL_AT           "@"
+ #define STR_A                       "A"
+ #define STR_B                       "B"
+ #define STR_C                       "C"
+ #define STR_D                       "D"
+ #define STR_E                       "E"
+ #define STR_F                       "F"
+ #define STR_G                       "G"
+ #define STR_H                       "H"
+ #define STR_I                       "I"
+ #define STR_J                       "J"
+ #define STR_K                       "K"
+ #define STR_L                       "L"
+ #define STR_M                       "M"
+ #define STR_N                       "N"
+ #define STR_O                       "O"
+ #define STR_P                       "P"
+ #define STR_Q                       "Q"
+ #define STR_R                       "R"
+ #define STR_S                       "S"
+ #define STR_T                       "T"
+ #define STR_U                       "U"
+ #define STR_V                       "V"
+ #define STR_W                       "W"
+ #define STR_X                       "X"
+ #define STR_Y                       "Y"
+ #define STR_Z                       "Z"
+ #define STR_LEFT_SQUARE_BRACKET     "["
+ #define STR_BACKSLASH               "\\"
+ #define STR_RIGHT_SQUARE_BRACKET    "]"
+ #define STR_CIRCUMFLEX_ACCENT       "^"
+ #define STR_UNDERSCORE              "_"
+ #define STR_GRAVE_ACCENT            "`"
+ #define STR_a                       "a"
+ #define STR_b                       "b"
+ #define STR_c                       "c"
+ #define STR_d                       "d"
+ #define STR_e                       "e"
+ #define STR_f                       "f"
+ #define STR_g                       "g"
+ #define STR_h                       "h"
+ #define STR_i                       "i"
+ #define STR_j                       "j"
+ #define STR_k                       "k"
+ #define STR_l                       "l"
+ #define STR_m                       "m"
+ #define STR_n                       "n"
+ #define STR_o                       "o"
+ #define STR_p                       "p"
+ #define STR_q                       "q"
+ #define STR_r                       "r"
+ #define STR_s                       "s"
+ #define STR_t                       "t"
+ #define STR_u                       "u"
+ #define STR_v                       "v"
+ #define STR_w                       "w"
+ #define STR_x                       "x"
+ #define STR_y                       "y"
+ #define STR_z                       "z"
+ #define STR_LEFT_CURLY_BRACKET      "{"
+ #define STR_VERTICAL_LINE           "|"
+ #define STR_RIGHT_CURLY_BRACKET     "}"
+ #define STR_TILDE                   "~"
+ #define STRING_ACCEPT0              "ACCEPT\0"
+ #define STRING_COMMIT0              "COMMIT\0"
+ #define STRING_F0                   "F\0"
+ #define STRING_FAIL0                "FAIL\0"
+ #define STRING_MARK0                "MARK\0"
+ #define STRING_PRUNE0               "PRUNE\0"
+ #define STRING_SKIP0                "SKIP\0"
+ #define STRING_THEN                 "THEN"
+ #define STRING_alpha0               "alpha\0"
+ #define STRING_lower0               "lower\0"
+ #define STRING_upper0               "upper\0"
+ #define STRING_alnum0               "alnum\0"
+ #define STRING_ascii0               "ascii\0"
+ #define STRING_blank0               "blank\0"
+ #define STRING_cntrl0               "cntrl\0"
+ #define STRING_digit0               "digit\0"
+ #define STRING_graph0               "graph\0"
+ #define STRING_print0               "print\0"
+ #define STRING_punct0               "punct\0"
+ #define STRING_space0               "space\0"
+ #define STRING_word0                "word\0"
+ #define STRING_xdigit               "xdigit"
+ #define STRING_DEFINE               "DEFINE"
+ #define STRING_CR_RIGHTPAR             "CR)"
+ #define STRING_LF_RIGHTPAR             "LF)"
+ #define STRING_CRLF_RIGHTPAR           "CRLF)"
+ #define STRING_ANY_RIGHTPAR            "ANY)"
+ #define STRING_ANYCRLF_RIGHTPAR        "ANYCRLF)"
+ #define STRING_BSR_ANYCRLF_RIGHTPAR    "BSR_ANYCRLF)"
+ #define STRING_BSR_UNICODE_RIGHTPAR    "BSR_UNICODE)"
+ #ifdef COMPILE_PCRE8
+ #define STRING_UTF_RIGHTPAR            "UTF8)"
+ #endif
+ #ifdef COMPILE_PCRE16
+ #define STRING_UTF_RIGHTPAR            "UTF16)"
+ #endif
+ #ifdef COMPILE_PCRE32
+ #define STRING_UTF_RIGHTPAR            "UTF32)"
+ #endif
+ #define STRING_UCP_RIGHTPAR            "UCP)"
+ #define STRING_NO_START_OPT_RIGHTPAR   "NO_START_OPT)"
+ #else  /* SUPPORT_UTF */
+ /* UTF-8 support is enabled; always use UTF-8 (=ASCII) character codes. This
+ works in both modes non-EBCDIC platforms, and on EBCDIC platforms in UTF-8 mode
+ only. */
+ #define CHAR_HT                     '\011'
+ #define CHAR_VT                     '\013'
+ #define CHAR_FF                     '\014'
+ #define CHAR_CR                     '\015'
+ #define CHAR_LF                     '\012'
+ #define CHAR_NL                     CHAR_LF
+ #define CHAR_NEL                    ((unsigned char)'\x85')
+ #define CHAR_BS                     '\010'
+ #define CHAR_BEL                    '\007'
+ #define CHAR_ESC                    '\033'
+ #define CHAR_DEL                    '\177'
+ #define CHAR_SPACE                  '\040'
+ #define CHAR_EXCLAMATION_MARK       '\041'
+ #define CHAR_QUOTATION_MARK         '\042'
+ #define CHAR_NUMBER_SIGN            '\043'
+ #define CHAR_DOLLAR_SIGN            '\044'
+ #define CHAR_PERCENT_SIGN           '\045'
+ #define CHAR_AMPERSAND              '\046'
+ #define CHAR_APOSTROPHE             '\047'
+ #define CHAR_LEFT_PARENTHESIS       '\050'
+ #define CHAR_RIGHT_PARENTHESIS      '\051'
+ #define CHAR_ASTERISK               '\052'
+ #define CHAR_PLUS                   '\053'
+ #define CHAR_COMMA                  '\054'
+ #define CHAR_MINUS                  '\055'
+ #define CHAR_DOT                    '\056'
+ #define CHAR_SLASH                  '\057'
+ #define CHAR_0                      '\060'
+ #define CHAR_1                      '\061'
+ #define CHAR_2                      '\062'
+ #define CHAR_3                      '\063'
+ #define CHAR_4                      '\064'
+ #define CHAR_5                      '\065'
+ #define CHAR_6                      '\066'
+ #define CHAR_7                      '\067'
+ #define CHAR_8                      '\070'
+ #define CHAR_9                      '\071'
+ #define CHAR_COLON                  '\072'
+ #define CHAR_SEMICOLON              '\073'
+ #define CHAR_LESS_THAN_SIGN         '\074'
+ #define CHAR_EQUALS_SIGN            '\075'
+ #define CHAR_GREATER_THAN_SIGN      '\076'
+ #define CHAR_QUESTION_MARK          '\077'
+ #define CHAR_COMMERCIAL_AT          '\100'
+ #define CHAR_A                      '\101'
+ #define CHAR_B                      '\102'
+ #define CHAR_C                      '\103'
+ #define CHAR_D                      '\104'
+ #define CHAR_E                      '\105'
+ #define CHAR_F                      '\106'
+ #define CHAR_G                      '\107'
+ #define CHAR_H                      '\110'
+ #define CHAR_I                      '\111'
+ #define CHAR_J                      '\112'
+ #define CHAR_K                      '\113'
+ #define CHAR_L                      '\114'
+ #define CHAR_M                      '\115'
+ #define CHAR_N                      '\116'
+ #define CHAR_O                      '\117'
+ #define CHAR_P                      '\120'
+ #define CHAR_Q                      '\121'
+ #define CHAR_R                      '\122'
+ #define CHAR_S                      '\123'
+ #define CHAR_T                      '\124'
+ #define CHAR_U                      '\125'
+ #define CHAR_V                      '\126'
+ #define CHAR_W                      '\127'
+ #define CHAR_X                      '\130'
+ #define CHAR_Y                      '\131'
+ #define CHAR_Z                      '\132'
+ #define CHAR_LEFT_SQUARE_BRACKET    '\133'
+ #define CHAR_BACKSLASH              '\134'
+ #define CHAR_RIGHT_SQUARE_BRACKET   '\135'
+ #define CHAR_CIRCUMFLEX_ACCENT      '\136'
+ #define CHAR_UNDERSCORE             '\137'
+ #define CHAR_GRAVE_ACCENT           '\140'
+ #define CHAR_a                      '\141'
+ #define CHAR_b                      '\142'
+ #define CHAR_c                      '\143'
+ #define CHAR_d                      '\144'
+ #define CHAR_e                      '\145'
+ #define CHAR_f                      '\146'
+ #define CHAR_g                      '\147'
+ #define CHAR_h                      '\150'
+ #define CHAR_i                      '\151'
+ #define CHAR_j                      '\152'
+ #define CHAR_k                      '\153'
+ #define CHAR_l                      '\154'
+ #define CHAR_m                      '\155'
+ #define CHAR_n                      '\156'
+ #define CHAR_o                      '\157'
+ #define CHAR_p                      '\160'
+ #define CHAR_q                      '\161'
+ #define CHAR_r                      '\162'
+ #define CHAR_s                      '\163'
+ #define CHAR_t                      '\164'
+ #define CHAR_u                      '\165'
+ #define CHAR_v                      '\166'
+ #define CHAR_w                      '\167'
+ #define CHAR_x                      '\170'
+ #define CHAR_y                      '\171'
+ #define CHAR_z                      '\172'
+ #define CHAR_LEFT_CURLY_BRACKET     '\173'
+ #define CHAR_VERTICAL_LINE          '\174'
+ #define CHAR_RIGHT_CURLY_BRACKET    '\175'
+ #define CHAR_TILDE                  '\176'
+ #define STR_HT                      "\011"
+ #define STR_VT                      "\013"
+ #define STR_FF                      "\014"
+ #define STR_CR                      "\015"
+ #define STR_NL                      "\012"
+ #define STR_BS                      "\010"
+ #define STR_BEL                     "\007"
+ #define STR_ESC                     "\033"
+ #define STR_DEL                     "\177"
+ #define STR_SPACE                   "\040"
+ #define STR_EXCLAMATION_MARK        "\041"
+ #define STR_QUOTATION_MARK          "\042"
+ #define STR_NUMBER_SIGN             "\043"
+ #define STR_DOLLAR_SIGN             "\044"
+ #define STR_PERCENT_SIGN            "\045"
+ #define STR_AMPERSAND               "\046"
+ #define STR_APOSTROPHE              "\047"
+ #define STR_LEFT_PARENTHESIS        "\050"
+ #define STR_RIGHT_PARENTHESIS       "\051"
+ #define STR_ASTERISK                "\052"
+ #define STR_PLUS                    "\053"
+ #define STR_COMMA                   "\054"
+ #define STR_MINUS                   "\055"
+ #define STR_DOT                     "\056"
+ #define STR_SLASH                   "\057"
+ #define STR_0                       "\060"
+ #define STR_1                       "\061"
+ #define STR_2                       "\062"
+ #define STR_3                       "\063"
+ #define STR_4                       "\064"
+ #define STR_5                       "\065"
+ #define STR_6                       "\066"
+ #define STR_7                       "\067"
+ #define STR_8                       "\070"
+ #define STR_9                       "\071"
+ #define STR_COLON                   "\072"
+ #define STR_SEMICOLON               "\073"
+ #define STR_LESS_THAN_SIGN          "\074"
+ #define STR_EQUALS_SIGN             "\075"
+ #define STR_GREATER_THAN_SIGN       "\076"
+ #define STR_QUESTION_MARK           "\077"
+ #define STR_COMMERCIAL_AT           "\100"
+ #define STR_A                       "\101"
+ #define STR_B                       "\102"
+ #define STR_C                       "\103"
+ #define STR_D                       "\104"
+ #define STR_E                       "\105"
+ #define STR_F                       "\106"
+ #define STR_G                       "\107"
+ #define STR_H                       "\110"
+ #define STR_I                       "\111"
+ #define STR_J                       "\112"
+ #define STR_K                       "\113"
+ #define STR_L                       "\114"
+ #define STR_M                       "\115"
+ #define STR_N                       "\116"
+ #define STR_O                       "\117"
+ #define STR_P                       "\120"
+ #define STR_Q                       "\121"
+ #define STR_R                       "\122"
+ #define STR_S                       "\123"
+ #define STR_T                       "\124"
+ #define STR_U                       "\125"
+ #define STR_V                       "\126"
+ #define STR_W                       "\127"
+ #define STR_X                       "\130"
+ #define STR_Y                       "\131"
+ #define STR_Z                       "\132"
+ #define STR_LEFT_SQUARE_BRACKET     "\133"
+ #define STR_BACKSLASH               "\134"
+ #define STR_RIGHT_SQUARE_BRACKET    "\135"
+ #define STR_CIRCUMFLEX_ACCENT       "\136"
+ #define STR_UNDERSCORE              "\137"
+ #define STR_GRAVE_ACCENT            "\140"
+ #define STR_a                       "\141"
+ #define STR_b                       "\142"
+ #define STR_c                       "\143"
+ #define STR_d                       "\144"
+ #define STR_e                       "\145"
+ #define STR_f                       "\146"
+ #define STR_g                       "\147"
+ #define STR_h                       "\150"
+ #define STR_i                       "\151"
+ #define STR_j                       "\152"
+ #define STR_k                       "\153"
+ #define STR_l                       "\154"
+ #define STR_m                       "\155"
+ #define STR_n                       "\156"
+ #define STR_o                       "\157"
+ #define STR_p                       "\160"
+ #define STR_q                       "\161"
+ #define STR_r                       "\162"
+ #define STR_s                       "\163"
+ #define STR_t                       "\164"
+ #define STR_u                       "\165"
+ #define STR_v                       "\166"
+ #define STR_w                       "\167"
+ #define STR_x                       "\170"
+ #define STR_y                       "\171"
+ #define STR_z                       "\172"
+ #define STR_LEFT_CURLY_BRACKET      "\173"
+ #define STR_VERTICAL_LINE           "\174"
+ #define STR_RIGHT_CURLY_BRACKET     "\175"
+ #define STR_TILDE                   "\176"
+ #define STRING_ACCEPT0              STR_A STR_C STR_C STR_E STR_P STR_T "\0"
+ #define STRING_COMMIT0              STR_C STR_O STR_M STR_M STR_I STR_T "\0"
+ #define STRING_F0                   STR_F "\0"
+ #define STRING_FAIL0                STR_F STR_A STR_I STR_L "\0"
+ #define STRING_MARK0                STR_M STR_A STR_R STR_K "\0"
+ #define STRING_PRUNE0               STR_P STR_R STR_U STR_N STR_E "\0"
+ #define STRING_SKIP0                STR_S STR_K STR_I STR_P "\0"
+ #define STRING_THEN                 STR_T STR_H STR_E STR_N
+ #define STRING_alpha0               STR_a STR_l STR_p STR_h STR_a "\0"
+ #define STRING_lower0               STR_l STR_o STR_w STR_e STR_r "\0"
+ #define STRING_upper0               STR_u STR_p STR_p STR_e STR_r "\0"
+ #define STRING_alnum0               STR_a STR_l STR_n STR_u STR_m "\0"
+ #define STRING_ascii0               STR_a STR_s STR_c STR_i STR_i "\0"
+ #define STRING_blank0               STR_b STR_l STR_a STR_n STR_k "\0"
+ #define STRING_cntrl0               STR_c STR_n STR_t STR_r STR_l "\0"
+ #define STRING_digit0               STR_d STR_i STR_g STR_i STR_t "\0"
+ #define STRING_graph0               STR_g STR_r STR_a STR_p STR_h "\0"
+ #define STRING_print0               STR_p STR_r STR_i STR_n STR_t "\0"
+ #define STRING_punct0               STR_p STR_u STR_n STR_c STR_t "\0"
+ #define STRING_space0               STR_s STR_p STR_a STR_c STR_e "\0"
+ #define STRING_word0                STR_w STR_o STR_r STR_d       "\0"
+ #define STRING_xdigit               STR_x STR_d STR_i STR_g STR_i STR_t
+ #define STRING_DEFINE               STR_D STR_E STR_F STR_I STR_N STR_E
+ #define STRING_CR_RIGHTPAR             STR_C STR_R STR_RIGHT_PARENTHESIS
+ #define STRING_LF_RIGHTPAR             STR_L STR_F STR_RIGHT_PARENTHESIS
+ #define STRING_CRLF_RIGHTPAR           STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
+ #define STRING_ANY_RIGHTPAR            STR_A STR_N STR_Y STR_RIGHT_PARENTHESIS
+ #define STRING_ANYCRLF_RIGHTPAR        STR_A STR_N STR_Y STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
+ #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
+ #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
+ #ifdef COMPILE_PCRE8
+ #define STRING_UTF_RIGHTPAR            STR_U STR_T STR_F STR_8 STR_RIGHT_PARENTHESIS
+ #endif
+ #ifdef COMPILE_PCRE16
+ #define STRING_UTF_RIGHTPAR            STR_U STR_T STR_F STR_1 STR_6 STR_RIGHT_PARENTHESIS
+ #endif
+ #ifdef COMPILE_PCRE32
+ #define STRING_UTF_RIGHTPAR            STR_U STR_T STR_F STR_3 STR_2 STR_RIGHT_PARENTHESIS
+ #endif
+ #define STRING_UCP_RIGHTPAR            STR_U STR_C STR_P STR_RIGHT_PARENTHESIS
+ #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
+ #endif  /* SUPPORT_UTF */
  /* Escape items that are just an encoding of a particular data value. */
  #ifndef ESC_e
- #define ESC_e 27
+ #define ESC_e CHAR_ESC
  #endif
  #ifndef ESC_f
- #define ESC_f '\f'
+ #define ESC_f CHAR_FF
  #endif
  #ifndef ESC_n
- #define ESC_n '\n'
+ #define ESC_n CHAR_LF
  #endif
  #ifndef ESC_r
- #define ESC_r '\r'
+ #define ESC_r CHAR_CR
  #endif
  /* We can't officially use ESC_t because it is a POSIX reserved identifier
  (presumably because of all the others like size_t). */
  #ifndef ESC_tee
- #define ESC_tee '\t'
+ #define ESC_tee CHAR_HT
  #endif
  /* Codes for different types of Unicode property */
  #define PT_ANY        0    /* Any property - matches all chars */
  #define PT_LAMP       1    /* L& - the union of Lu, Ll, Lt */
- #define PT_GC         2    /* General characteristic (e.g. L) */
+ #define PT_GC         2    /* Specified general characteristic (e.g. L) */
- #define PT_PC         3    /* Particular characteristic (e.g. Lu) */
+ #define PT_PC         3    /* Specified particular characteristic (e.g. Lu) */
  #define PT_SC         4    /* Script (e.g. Han) */
+ #define PT_ALNUM      5    /* Alphanumeric - the union of L and N */
+ #define PT_SPACE      6    /* Perl space - Z plus 9,10,12,13 */
+ #define PT_PXSPACE    7    /* POSIX space - Z plus 9,10,11,12,13 */
+ #define PT_WORD       8    /* Word - L plus N plus underscore */
+ #define PT_CLIST      9    /* Pseudo-property: match character list */
  /* Flag bits and data types for the extended class (OP_XCLASS) for classes that
- contain UTF-8 characters with values greater than 255. */
+ contain characters with values greater than 255. */
  #define XCL_NOT    0x01    /* Flag: this is a negative class */
  #define XCL_MAP    0x02    /* Flag: a 32-byte map is present */
-Line 608 
 contain UTF-8 characters with values gre
+Line 1765 
 contain UTF-8 characters with values gre
  /* These are escaped items that aren't just an encoding of a particular data
  value such as \n. They must have non-zero values, as check_escape() returns
  their negation. Also, they must appear in the same order as in the opcode
- definitions below, up to ESC_z. There's a dummy for OP_ANY because it
+ definitions below, up to ESC_z. There's a dummy for OP_ALLANY because it
- corresponds to "." rather than an escape sequence, and another for OP_ALLANY
+ corresponds to "." in DOTALL mode rather than an escape sequence. It is also
- (which is used for [^] in JavaScript compatibility mode).
+ used for [^] in JavaScript compatibility mode, and for \C in non-utf mode. In
+ non-DOTALL mode, "." behaves like \N.
+ The special values ESC_DU, ESC_du, etc. are used instead of ESC_D, ESC_d, etc.
+ when PCRE_UCP is set and replacement of \d etc by \p sequences is required.
+ They must be contiguous, and remain in order so that the replacements can be
+ looked up from a table.
  The final escape must be ESC_REF as subsequent values are used for
  backreferences (\1, \2, \3, etc). There are two tests in the code for an escape
-Line 620 
 put in between that don't consume a char
+Line 1783 
 put in between that don't consume a char
  */
  enum { ESC_A = 1, ESC_G, ESC_K, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s,
-        ESC_W, ESC_w, ESC_dum1, ESC_dum2, ESC_C, ESC_P, ESC_p, ESC_R, ESC_H,
+        ESC_W, ESC_w, ESC_N, ESC_dum, ESC_C, ESC_P, ESC_p, ESC_R, ESC_H,
-        ESC_h, ESC_V, ESC_v, ESC_X, ESC_Z, ESC_z, ESC_E, ESC_Q, ESC_g, ESC_k,
+        ESC_h, ESC_V, ESC_v, ESC_X, ESC_Z, ESC_z,
+        ESC_E, ESC_Q, ESC_g, ESC_k,
+        ESC_DU, ESC_du, ESC_SU, ESC_su, ESC_WU, ESC_wu,
         ESC_REF };
  /* Opcode table: Starting from 1 (i.e. after OP_END), the values up to
  OP_EOD must correspond in order to the list of escapes immediately above.
  *** NOTE NOTE NOTE *** Whenever this list is updated, the two macro definitions
- that follow must also be updated to match. There is also a table called
+ that follow must also be updated to match. There are also tables called
- "coptable" in pcre_dfa_exec.c that must be updated. */
+ "coptable" and "poptable" in pcre_dfa_exec.c that must be updated. */
  enum {
    OP_END,            /* 0 End of pattern */
-Line 648 
 enum {
+Line 1812 
 enum {
    OP_WHITESPACE,         /*  9 \s */
    OP_NOT_WORDCHAR,       /* 10 \W */
    OP_WORDCHAR,           /* 11 \w */
-   OP_ANY,            /* 12 Match any character (subject to DOTALL) */
-   OP_ALLANY,         /* 13 Match any character (not subject to DOTALL) */
+   OP_ANY,            /* 12 Match any character except newline (\N) */
+   OP_ALLANY,         /* 13 Match any character */
    OP_ANYBYTE,        /* 14 Match any byte (\C); different to OP_ANY for UTF-8 */
    OP_NOTPROP,        /* 15 \P (not Unicode property) */
    OP_PROP,           /* 16 \p (Unicode property) */
-Line 659 
 enum {
+Line 1824 
 enum {
    OP_NOT_VSPACE,     /* 20 \V (not vertical whitespace) */
    OP_VSPACE,         /* 21 \v (vertical whitespace) */
    OP_EXTUNI,         /* 22 \X (extended Unicode sequence */
-   OP_EODN,           /* 23 End of data or \n at end of data: \Z. */
+   OP_EODN,           /* 23 End of data or \n at end of data (\Z) */
-   OP_EOD,            /* 24 End of data: \z */
+   OP_EOD,            /* 24 End of data (\z) */
-   OP_OPT,            /* 25 Set runtime options */
+   OP_CIRC,           /* 25 Start of line - not multiline */
-   OP_CIRC,           /* 26 Start of line - varies with multiline switch */
+   OP_CIRCM,          /* 26 Start of line - multiline */
-   OP_DOLL,           /* 27 End of line - varies with multiline switch */
+   OP_DOLL,           /* 27 End of line - not multiline */
-   OP_CHAR,           /* 28 Match one character, casefully */
+   OP_DOLLM,          /* 28 End of line - multiline */
-   OP_CHARNC,         /* 29 Match one character, caselessly */
+   OP_CHAR,           /* 29 Match one character, casefully */
-   OP_NOT,            /* 30 Match one character, not the following one */
+   OP_CHARI,          /* 30 Match one character, caselessly */
+   OP_NOT,            /* 31 Match one character, not the given one, casefully */
-   OP_STAR,           /* 31 The maximizing and minimizing versions of */
+   OP_NOTI,           /* 32 Match one character, not the given one, caselessly */
-   OP_MINSTAR,        /* 32 these six opcodes must come in pairs, with */
-   OP_PLUS,           /* 33 the minimizing one second. */
+   /* The following sets of 13 opcodes must always be kept in step because
-   OP_MINPLUS,        /* 34 This first set applies to single characters.*/
+   the offset from the first one is used to generate the others. */
-   OP_QUERY,          /* 35 */
-   OP_MINQUERY,       /* 36 */
+   /**** Single characters, caseful, must precede the caseless ones ****/
-   OP_UPTO,           /* 37 From 0 to n matches */
+   OP_STAR,           /* 33 The maximizing and minimizing versions of */
-   OP_MINUPTO,        /* 38 */
+   OP_MINSTAR,        /* 34 these six opcodes must come in pairs, with */
-   OP_EXACT,          /* 39 Exactly n matches */
+   OP_PLUS,           /* 35 the minimizing one second. */
+   OP_MINPLUS,        /* 36 */
-   OP_POSSTAR,        /* 40 Possessified star */
+   OP_QUERY,          /* 37 */
-   OP_POSPLUS,        /* 41 Possessified plus */
+   OP_MINQUERY,       /* 38 */
-   OP_POSQUERY,       /* 42 Posesssified query */
-   OP_POSUPTO,        /* 43 Possessified upto */
+   OP_UPTO,           /* 39 From 0 to n matches of one character, caseful*/
+   OP_MINUPTO,        /* 40 */
-   OP_NOTSTAR,        /* 44 The maximizing and minimizing versions of */
+   OP_EXACT,          /* 41 Exactly n matches */
-   OP_NOTMINSTAR,     /* 45 these six opcodes must come in pairs, with */
-   OP_NOTPLUS,        /* 46 the minimizing one second. They must be in */
+   OP_POSSTAR,        /* 42 Possessified star, caseful */
-   OP_NOTMINPLUS,     /* 47 exactly the same order as those above. */
+   OP_POSPLUS,        /* 43 Possessified plus, caseful */
-   OP_NOTQUERY,       /* 48 This set applies to "not" single characters. */
+   OP_POSQUERY,       /* 44 Posesssified query, caseful */
-   OP_NOTMINQUERY,    /* 49 */
+   OP_POSUPTO,        /* 45 Possessified upto, caseful */
-   OP_NOTUPTO,        /* 50 From 0 to n matches */
+   /**** Single characters, caseless, must follow the caseful ones */
-   OP_NOTMINUPTO,     /* 51 */
-   OP_NOTEXACT,       /* 52 Exactly n matches */
+   OP_STARI,          /* 46 */
+   OP_MINSTARI,       /* 47 */
-   OP_NOTPOSSTAR,     /* 53 Possessified versions */
+   OP_PLUSI,          /* 48 */
-   OP_NOTPOSPLUS,     /* 54 */
+   OP_MINPLUSI,       /* 49 */
-   OP_NOTPOSQUERY,    /* 55 */
+   OP_QUERYI,         /* 50 */
-   OP_NOTPOSUPTO,     /* 56 */
+   OP_MINQUERYI,      /* 51 */
-   OP_TYPESTAR,       /* 57 The maximizing and minimizing versions of */
+   OP_UPTOI,          /* 52 From 0 to n matches of one character, caseless */
-   OP_TYPEMINSTAR,    /* 58 these six opcodes must come in pairs, with */
+   OP_MINUPTOI,       /* 53 */
-   OP_TYPEPLUS,       /* 59 the minimizing one second. These codes must */
+   OP_EXACTI,         /* 54 */
-   OP_TYPEMINPLUS,    /* 60 be in exactly the same order as those above. */
-   OP_TYPEQUERY,      /* 61 This set applies to character types such as \d */
+   OP_POSSTARI,       /* 55 Possessified star, caseless */
-   OP_TYPEMINQUERY,   /* 62 */
+   OP_POSPLUSI,       /* 56 Possessified plus, caseless */
+   OP_POSQUERYI,      /* 57 Posesssified query, caseless */
-   OP_TYPEUPTO,       /* 63 From 0 to n matches */
+   OP_POSUPTOI,       /* 58 Possessified upto, caseless */
-   OP_TYPEMINUPTO,    /* 64 */
-   OP_TYPEEXACT,      /* 65 Exactly n matches */
+   /**** The negated ones must follow the non-negated ones, and match them ****/
+   /**** Negated single character, caseful; must precede the caseless ones ****/
-   OP_TYPEPOSSTAR,    /* 66 Possessified versions */
-   OP_TYPEPOSPLUS,    /* 67 */
+   OP_NOTSTAR,        /* 59 The maximizing and minimizing versions of */
-   OP_TYPEPOSQUERY,   /* 68 */
+   OP_NOTMINSTAR,     /* 60 these six opcodes must come in pairs, with */
-   OP_TYPEPOSUPTO,    /* 69 */
+   OP_NOTPLUS,        /* 61 the minimizing one second. They must be in */
+   OP_NOTMINPLUS,     /* 62 exactly the same order as those above. */
-   OP_CRSTAR,         /* 70 The maximizing and minimizing versions of */
+   OP_NOTQUERY,       /* 63 */
-   OP_CRMINSTAR,      /* 71 all these opcodes must come in pairs, with */
+   OP_NOTMINQUERY,    /* 64 */
-   OP_CRPLUS,         /* 72 the minimizing one second. These codes must */
-   OP_CRMINPLUS,      /* 73 be in exactly the same order as those above. */
+   OP_NOTUPTO,        /* 65 From 0 to n matches, caseful */
-   OP_CRQUERY,        /* 74 These are for character classes and back refs */
+   OP_NOTMINUPTO,     /* 66 */
-   OP_CRMINQUERY,     /* 75 */
+   OP_NOTEXACT,       /* 67 Exactly n matches */
-   OP_CRRANGE,        /* 76 These are different to the three sets above. */
-   OP_CRMINRANGE,     /* 77 */
+   OP_NOTPOSSTAR,     /* 68 Possessified versions, caseful */
+   OP_NOTPOSPLUS,     /* 69 */
-   OP_CLASS,          /* 78 Match a character class, chars < 256 only */
+   OP_NOTPOSQUERY,    /* 70 */
-   OP_NCLASS,         /* 79 Same, but the bitmap was created from a negative
+   OP_NOTPOSUPTO,     /* 71 */
-                            class - the difference is relevant only when a UTF-8
-                            character > 255 is encountered. */
+   /**** Negated single character, caseless; must follow the caseful ones ****/
-   OP_XCLASS,         /* 80 Extended class for handling UTF-8 chars within the
+   OP_NOTSTARI,       /* 72 */
-                            class. This does both positive and negative. */
+   OP_NOTMINSTARI,    /* 73 */
+   OP_NOTPLUSI,       /* 74 */
-   OP_REF,            /* 81 Match a back reference */
+   OP_NOTMINPLUSI,    /* 75 */
-   OP_RECURSE,        /* 82 Match a numbered subpattern (possibly recursive) */
+   OP_NOTQUERYI,      /* 76 */
-   OP_CALLOUT,        /* 83 Call out to external function if provided */
+   OP_NOTMINQUERYI,   /* 77 */
-   OP_ALT,            /* 84 Start of alternation */
+   OP_NOTUPTOI,       /* 78 From 0 to n matches, caseless */
-   OP_KET,            /* 85 End of group that doesn't have an unbounded repeat */
+   OP_NOTMINUPTOI,    /* 79 */
-   OP_KETRMAX,        /* 86 These two must remain together and in this */
+   OP_NOTEXACTI,      /* 80 Exactly n matches */
-   OP_KETRMIN,        /* 87 order. They are for groups the repeat for ever. */
+   OP_NOTPOSSTARI,    /* 81 Possessified versions, caseless */
-   /* The assertions must come before BRA, CBRA, ONCE, and COND.*/
+   OP_NOTPOSPLUSI,    /* 82 */
+   OP_NOTPOSQUERYI,   /* 83 */
-   OP_ASSERT,         /* 88 Positive lookahead */
+   OP_NOTPOSUPTOI,    /* 84 */
-   OP_ASSERT_NOT,     /* 89 Negative lookahead */
-   OP_ASSERTBACK,     /* 90 Positive lookbehind */
+   /**** Character types ****/
-   OP_ASSERTBACK_NOT, /* 91 Negative lookbehind */
-   OP_REVERSE,        /* 92 Move pointer back - used in lookbehind assertions */
+   OP_TYPESTAR,       /* 85 The maximizing and minimizing versions of */
+   OP_TYPEMINSTAR,    /* 86 these six opcodes must come in pairs, with */
-   /* ONCE, BRA, CBRA, and COND must come after the assertions, with ONCE first,
+   OP_TYPEPLUS,       /* 87 the minimizing one second. These codes must */
-   as there's a test for >= ONCE for a subpattern that isn't an assertion. */
+   OP_TYPEMINPLUS,    /* 88 be in exactly the same order as those above. */
+   OP_TYPEQUERY,      /* 89 */
-   OP_ONCE,           /* 93 Atomic group */
+   OP_TYPEMINQUERY,   /* 90 */
-   OP_BRA,            /* 94 Start of non-capturing bracket */
-   OP_CBRA,           /* 95 Start of capturing bracket */
+   OP_TYPEUPTO,       /* 91 From 0 to n matches */
-   OP_COND,           /* 96 Conditional group */
+   OP_TYPEMINUPTO,    /* 92 */
+   OP_TYPEEXACT,      /* 93 Exactly n matches */
+   OP_TYPEPOSSTAR,    /* 94 Possessified versions */
+   OP_TYPEPOSPLUS,    /* 95 */
+   OP_TYPEPOSQUERY,   /* 96 */
+   OP_TYPEPOSUPTO,    /* 97 */
+   /* These are used for character classes and back references; only the
+   first six are the same as the sets above. */
+   OP_CRSTAR,         /* 98 The maximizing and minimizing versions of */
+   OP_CRMINSTAR,      /* 99 all these opcodes must come in pairs, with */
+   OP_CRPLUS,         /* 100 the minimizing one second. These codes must */
+   OP_CRMINPLUS,      /* 101 be in exactly the same order as those above. */
+   OP_CRQUERY,        /* 102 */
+   OP_CRMINQUERY,     /* 103 */
+   OP_CRRANGE,        /* 104 These are different to the three sets above. */
+   OP_CRMINRANGE,     /* 105 */
+   /* End of quantifier opcodes */
+   OP_CLASS,          /* 106 Match a character class, chars < 256 only */
+   OP_NCLASS,         /* 107 Same, but the bitmap was created from a negative
+                               class - the difference is relevant only when a
+                               character > 255 is encountered. */
+   OP_XCLASS,         /* 108 Extended class for handling > 255 chars within the
+                               class. This does both positive and negative. */
+   OP_REF,            /* 109 Match a back reference, casefully */
+   OP_REFI,           /* 110 Match a back reference, caselessly */
+   OP_RECURSE,        /* 111 Match a numbered subpattern (possibly recursive) */
+   OP_CALLOUT,        /* 112 Call out to external function if provided */
+   OP_ALT,            /* 113 Start of alternation */
+   OP_KET,            /* 114 End of group that doesn't have an unbounded repeat */
+   OP_KETRMAX,        /* 115 These two must remain together and in this */
+   OP_KETRMIN,        /* 116 order. They are for groups the repeat for ever. */
+   OP_KETRPOS,        /* 117 Possessive unlimited repeat. */
+   /* The assertions must come before BRA, CBRA, ONCE, and COND, and the four
+   asserts must remain in order. */
+   OP_REVERSE,        /* 118 Move pointer back - used in lookbehind assertions */
+   OP_ASSERT,         /* 119 Positive lookahead */
+   OP_ASSERT_NOT,     /* 120 Negative lookahead */
+   OP_ASSERTBACK,     /* 121 Positive lookbehind */
+   OP_ASSERTBACK_NOT, /* 122 Negative lookbehind */
+   /* ONCE, ONCE_NC, BRA, BRAPOS, CBRA, CBRAPOS, and COND must come immediately
+   after the assertions, with ONCE first, as there's a test for >= ONCE for a
+   subpattern that isn't an assertion. The POS versions must immediately follow
+   the non-POS versions in each case. */
+   OP_ONCE,           /* 123 Atomic group, contains captures */
+   OP_ONCE_NC,        /* 124 Atomic group containing no captures */
+   OP_BRA,            /* 125 Start of non-capturing bracket */
+   OP_BRAPOS,         /* 126 Ditto, with unlimited, possessive repeat */
+   OP_CBRA,           /* 127 Start of capturing bracket */
+   OP_CBRAPOS,        /* 128 Ditto, with unlimited, possessive repeat */
+   OP_COND,           /* 129 Conditional group */
-   /* These three must follow the previous three, in the same order. There's a
+   /* These five must follow the previous five, in the same order. There's a
    check for >= SBRA to distinguish the two sets. */
-   OP_SBRA,           /* 97 Start of non-capturing bracket, check empty  */
+   OP_SBRA,           /* 130 Start of non-capturing bracket, check empty  */
-   OP_SCBRA,          /* 98 Start of capturing bracket, check empty */
+   OP_SBRAPOS,        /* 131 Ditto, with unlimited, possessive repeat */
-   OP_SCOND,          /* 99 Conditional group, check empty */
+   OP_SCBRA,          /* 132 Start of capturing bracket, check empty */
+   OP_SCBRAPOS,       /* 133 Ditto, with unlimited, possessive repeat */
-   OP_CREF,           /* 100 Used to hold a capture number as condition */
+   OP_SCOND,          /* 134 Conditional group, check empty */
-   OP_RREF,           /* 101 Used to hold a recursion number as condition */
-   OP_DEF,            /* 102 The DEFINE condition */
+   /* The next two pairs must (respectively) be kept together. */
-   OP_BRAZERO,        /* 103 These two must remain together and in this */
+   OP_CREF,           /* 135 Used to hold a capture number as condition */
-   OP_BRAMINZERO,     /* 104 order. */
+   OP_NCREF,          /* 136 Same, but generated by a name reference*/
+   OP_RREF,           /* 137 Used to hold a recursion number as condition */
+   OP_NRREF,          /* 138 Same, but generated by a name reference*/
+   OP_DEF,            /* 139 The DEFINE condition */
+   OP_BRAZERO,        /* 140 These two must remain together and in this */
+   OP_BRAMINZERO,     /* 141 order. */
+   OP_BRAPOSZERO,     /* 142 */
    /* These are backtracking control verbs */
-   OP_PRUNE,          /* 105 */
+   OP_MARK,           /* 143 always has an argument */
-   OP_SKIP,           /* 106 */
+   OP_PRUNE,          /* 144 */
-   OP_THEN,           /* 107 */
+   OP_PRUNE_ARG,      /* 145 same, but with argument */
-   OP_COMMIT,         /* 108 */
+   OP_SKIP,           /* 146 */
+   OP_SKIP_ARG,       /* 147 same, but with argument */
+   OP_THEN,           /* 148 */
+   OP_THEN_ARG,       /* 149 same, but with argument */
+   OP_COMMIT,         /* 150 */
    /* These are forced failure and success verbs */
-   OP_FAIL,           /* 109 */
+   OP_FAIL,           /* 151 */
-   OP_ACCEPT,         /* 110 */
+   OP_ACCEPT,         /* 152 */
+   OP_ASSERT_ACCEPT,  /* 153 Used inside assertions */
+   OP_CLOSE,          /* 154 Used before OP_ACCEPT to close open captures */
    /* This is used to skip a subpattern with a {0} quantifier */
-   OP_SKIPZERO        /* 111 */
+   OP_SKIPZERO,       /* 155 */
+   /* This is not an opcode, but is used to check that tables indexed by opcode
+   are the correct length, in order to catch updating errors - there have been
+   some in the past. */
+   OP_TABLE_LENGTH
  };
+ /* *** NOTE NOTE NOTE *** Whenever the list above is updated, the two macro
+ definitions that follow must also be updated to match. There are also tables
+ called "coptable" and "poptable" in pcre_dfa_exec.c that must be updated. */
  /* This macro defines textual names for all the opcodes. These are used only
- for debugging. The macro is referenced only in pcre_printint.c. */
+ for debugging, and some of them are only partial names. The macro is referenced
+ only in pcre_printint.c, which fills out the full names in many cases (and in
+ some cases doesn't actually use these names at all). */
  #define OP_NAME_LIST \
    "End", "\\A", "\\G", "\\K", "\\B", "\\b", "\\D", "\\d",         \
    "\\S", "\\s", "\\W", "\\w", "Any", "AllAny", "Anybyte",         \
    "notprop", "prop", "\\R", "\\H", "\\h", "\\V", "\\v",           \
    "extuni",  "\\Z", "\\z",                                        \
-   "Opt", "^", "$", "char", "charnc", "not",                       \
+   "^", "^", "$", "$", "char", "chari", "not", "noti",             \
-   "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+   "*", "*?", "+", "+?", "?", "??",                                \
+   "{", "{", "{",                                                  \
    "*+","++", "?+", "{",                                           \
-   "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+   "*", "*?", "+", "+?", "?", "??",                                \
+   "{", "{", "{",                                                  \
+   "*+","++", "?+", "{",                                           \
+   "*", "*?", "+", "+?", "?", "??",                                \
+   "{", "{", "{",                                                  \
+   "*+","++", "?+", "{",                                           \
+   "*", "*?", "+", "+?", "?", "??",                                \
+   "{", "{", "{",                                                  \
    "*+","++", "?+", "{",                                           \
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
    "*+","++", "?+", "{",                                           \
    "*", "*?", "+", "+?", "?", "??", "{", "{",                      \
-   "class", "nclass", "xclass", "Ref", "Recurse", "Callout",       \
+   "class", "nclass", "xclass", "Ref", "Refi",                     \
-   "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",     \
+   "Recurse", "Callout",                                           \
-   "AssertB", "AssertB not", "Reverse",                            \
+   "Alt", "Ket", "KetRmax", "KetRmin", "KetRpos",                  \
-   "Once", "Bra", "CBra", "Cond", "SBra", "SCBra", "SCond",        \
+   "Reverse", "Assert", "Assert not", "AssertB", "AssertB not",    \
-   "Cond ref", "Cond rec", "Cond def", "Brazero", "Braminzero",    \
+   "Once", "Once_NC",                                              \
-   "*PRUNE", "*SKIP", "*THEN", "*COMMIT", "*FAIL", "*ACCEPT",      \
+   "Bra", "BraPos", "CBra", "CBraPos",                             \
-   "Skip zero"
+   "Cond",                                                         \
+   "SBra", "SBraPos", "SCBra", "SCBraPos",                         \
+   "SCond",                                                        \
+   "Cond ref", "Cond nref", "Cond rec", "Cond nrec", "Cond def",   \
+   "Brazero", "Braminzero", "Braposzero",                          \
+   "*MARK", "*PRUNE", "*PRUNE", "*SKIP", "*SKIP",                  \
+   "*THEN", "*THEN", "*COMMIT", "*FAIL",                           \
+   "*ACCEPT", "*ASSERT_ACCEPT",                                    \
+   "Close", "Skip zero"
  /* This macro defines the length of fixed length operations in the compiled
-Line 830 
 in UTF-8 mode. The code that uses this t
+Line 2096 
 in UTF-8 mode. The code that uses this t
 , 1, 1, 1, 1,                 /* \A, \G, \K, \B, \b                     */ \
 , 1, 1, 1, 1, 1,              /* \D, \d, \S, \s, \W, \w                 */ \
 , 1, 1,                       /* Any, AllAny, Anybyte                   */ \
-, 3, 1,                       /* NOTPROP, PROP, EXTUNI                  */ \
+, 3,                          /* \P, \p                                 */ \
 , 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */ \
-, 1, 2, 1, 1,                 /* \Z, \z, Opt, ^, $                      */ \
+,                             /* \X                                     */ \
+, 1, 1, 1, 1, 1,              /* \Z, \z, ^, ^M, $, $M                   */ \
 ,                             /* Char  - the minimum length             */ \
-,                             /* Charnc  - the minimum length           */ \
+,                             /* Chari  - the minimum length            */ \
 ,                             /* not                                    */ \
-   /* Positive single-char repeats                            ** These are  */ \
+,                             /* noti                                   */ \
-, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??      ** minima in  */ \
+   /* Positive single-char repeats                             ** These are */ \
-, 4, 4,                       /* upto, minupto, exact     ** UTF-8 mode */ \
+, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??       ** minima in */ \
-, 2, 2, 4,                    /* *+, ++, ?+, upto+                      */ \
++IMM2_SIZE, 2+IMM2_SIZE,      /* upto, minupto             ** mode      */ \
++IMM2_SIZE,                   /* exact                                  */ \
+, 2, 2, 2+IMM2_SIZE,          /* *+, ++, ?+, upto+                      */ \
+, 2, 2, 2, 2, 2,              /* *I, *?I, +I, +?I, ?I, ??I ** UTF-8     */ \
++IMM2_SIZE, 2+IMM2_SIZE,      /* upto I, minupto I                      */ \
++IMM2_SIZE,                   /* exact I                                */ \
+, 2, 2, 2+IMM2_SIZE,          /* *+I, ++I, ?+I, upto+I                  */ \
    /* Negative single-char repeats - only for chars < 256                   */ \
 , 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \
-, 4, 4,                       /* NOT upto, minupto, exact               */ \
++IMM2_SIZE, 2+IMM2_SIZE,      /* NOT upto, minupto                      */ \
-, 2, 2, 4,                    /* Possessive *, +, ?, upto               */ \
++IMM2_SIZE,                   /* NOT exact                              */ \
+, 2, 2, 2+IMM2_SIZE,          /* Possessive NOT *, +, ?, upto           */ \
+, 2, 2, 2, 2, 2,              /* NOT *I, *?I, +I, +?I, ?I, ??I          */ \
++IMM2_SIZE, 2+IMM2_SIZE,      /* NOT upto I, minupto I                  */ \
++IMM2_SIZE,                   /* NOT exact I                            */ \
+, 2, 2, 2+IMM2_SIZE,          /* Possessive NOT *I, +I, ?I, upto I      */ \
    /* Positive type repeats                                                 */ \
 , 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \
-, 4, 4,                       /* Type upto, minupto, exact              */ \
++IMM2_SIZE, 2+IMM2_SIZE,      /* Type upto, minupto                     */ \
-, 2, 2, 4,                    /* Possessive *+, ++, ?+, upto+           */ \
++IMM2_SIZE,                   /* Type exact                             */ \
+, 2, 2, 2+IMM2_SIZE,          /* Possessive *+, ++, ?+, upto+           */ \
    /* Character class & ref repeats                                         */ \
 , 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */ \
-, 5,                          /* CRRANGE, CRMINRANGE                    */ \
++2*IMM2_SIZE, 1+2*IMM2_SIZE,  /* CRRANGE, CRMINRANGE                    */ \
-,                             /* CLASS                                  */ \
++(32/sizeof(pcre_uchar)),     /* CLASS                                  */ \
-,                             /* NCLASS                                 */ \
++(32/sizeof(pcre_uchar)),     /* NCLASS                                 */ \
 ,                             /* XCLASS - variable length               */ \
-,                             /* REF                                    */ \
++IMM2_SIZE,                   /* REF                                    */ \
++IMM2_SIZE,                   /* REFI                                   */ \
 +LINK_SIZE,                   /* RECURSE                                */ \
 +2*LINK_SIZE,                 /* CALLOUT                                */ \
 +LINK_SIZE,                   /* Alt                                    */ \
 +LINK_SIZE,                   /* Ket                                    */ \
 +LINK_SIZE,                   /* KetRmax                                */ \
 +LINK_SIZE,                   /* KetRmin                                */ \
++LINK_SIZE,                   /* KetRpos                                */ \
++LINK_SIZE,                   /* Reverse                                */ \
 +LINK_SIZE,                   /* Assert                                 */ \
 +LINK_SIZE,                   /* Assert not                             */ \
 +LINK_SIZE,                   /* Assert behind                          */ \
 +LINK_SIZE,                   /* Assert behind not                      */ \
-+LINK_SIZE,                   /* Reverse                                */ \
 +LINK_SIZE,                   /* ONCE                                   */ \
++LINK_SIZE,                   /* ONCE_NC                                */ \
 +LINK_SIZE,                   /* BRA                                    */ \
-+LINK_SIZE,                   /* CBRA                                   */ \
++LINK_SIZE,                   /* BRAPOS                                 */ \
++LINK_SIZE+IMM2_SIZE,         /* CBRA                                   */ \
++LINK_SIZE+IMM2_SIZE,         /* CBRAPOS                                */ \
 +LINK_SIZE,                   /* COND                                   */ \
 +LINK_SIZE,                   /* SBRA                                   */ \
-+LINK_SIZE,                   /* SCBRA                                  */ \
++LINK_SIZE,                   /* SBRAPOS                                */ \
++LINK_SIZE+IMM2_SIZE,         /* SCBRA                                  */ \
++LINK_SIZE+IMM2_SIZE,         /* SCBRAPOS                               */ \
 +LINK_SIZE,                   /* SCOND                                  */ \
-,                             /* CREF                                   */ \
++IMM2_SIZE, 1+IMM2_SIZE,      /* CREF, NCREF                            */ \
-,                             /* RREF                                   */ \
++IMM2_SIZE, 1+IMM2_SIZE,      /* RREF, NRREF                            */ \
 ,                             /* DEF                                    */ \
-, 1,                          /* BRAZERO, BRAMINZERO                    */ \
+, 1, 1,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */ \
-, 1, 1, 1,                    /* PRUNE, SKIP, THEN, COMMIT,             */ \
+, 1, 3,                       /* MARK, PRUNE, PRUNE_ARG                 */ \
-, 1, 1                        /* FAIL, ACCEPT, SKIPZERO                 */
+, 3,                          /* SKIP, SKIP_ARG                         */ \
+, 3,                          /* THEN, THEN_ARG                         */ \
+, 1, 1, 1,                    /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT    */ \
++IMM2_SIZE, 1                 /* CLOSE, SKIPZERO                        */
+ /* A magic value for OP_RREF and OP_NRREF to indicate the "any recursion"
- /* A magic value for OP_RREF to indicate the "any recursion" condition. */
+ condition. */
  #define RREF_ANY  0xffff
- /* Error code numbers. They are given names so that they can more easily be
+ /* Compile time error code numbers. They are given names so that they can more
- tracked. */
+ easily be tracked. When a new number is added, the table called eint in
+ pcreposix.c must be updated. */
  enum { ERR0,  ERR1,  ERR2,  ERR3,  ERR4,  ERR5,  ERR6,  ERR7,  ERR8,  ERR9,
         ERR10, ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19,
-Line 894 
 enum { ERR0,  ERR1,  ERR2,  ERR3,  ERR4,
+Line 2184 
 enum { ERR0,  ERR1,  ERR2,  ERR3,  ERR4,
         ERR30, ERR31, ERR32, ERR33, ERR34, ERR35, ERR36, ERR37, ERR38, ERR39,
         ERR40, ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47, ERR48, ERR49,
         ERR50, ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57, ERR58, ERR59,
-        ERR60, ERR61, ERR62, ERR63, ERR64 };
+        ERR60, ERR61, ERR62, ERR63, ERR64, ERR65, ERR66, ERR67, ERR68, ERR69,
+        ERR70, ERR71, ERR72, ERR73, ERR74, ERR75, ERR76, ERR77, ERRCOUNT };
+ /* JIT compiling modes. The function list is indexed by them. */
+ enum { JIT_COMPILE, JIT_PARTIAL_SOFT_COMPILE, JIT_PARTIAL_HARD_COMPILE,
+        JIT_NUMBER_OF_COMPILE_MODES };
  /* The real format of the start of the pcre block; the index of names and the
  code vector run on as long as necessary after the end. We store an explicit
-Line 910 
 Because people can now save and re-use c
+Line 2205 
 Because people can now save and re-use c
  structure should be made at the end, and something earlier (e.g. a new
  flag in the options or one of the dummy fields) should indicate that the new
  fields are present. Currently PCRE always sets the dummy fields to zero.
- NOTE NOTE NOTE:
+ NOTE NOTE NOTE
  */
- typedef struct real_pcre {
+ #if defined COMPILE_PCRE8
+ #define REAL_PCRE real_pcre
+ #elif defined COMPILE_PCRE16
+ #define REAL_PCRE real_pcre16
+ #elif defined COMPILE_PCRE32
+ #define REAL_PCRE real_pcre32
+ #endif
+ /* It is necessary to fork the struct for 32 bit, since it needs to use
+  * pcre_uchar for first_char and req_char. Can't put an ifdef inside the
+  * typedef since pcretest needs access to  the struct of the 8-, 16-
+  * and 32-bit variants. */
+ typedef struct real_pcre8_or_16 {
    pcre_uint32 magic_number;
    pcre_uint32 size;               /* Total that was malloced */
    pcre_uint32 options;            /* Public options */
    pcre_uint16 flags;              /* Private flags */
-   pcre_uint16 dummy1;             /* For future use */
+   pcre_uint16 max_lookbehind;     /* Longest lookbehind (characters) */
-   pcre_uint16 top_bracket;
+   pcre_uint16 top_bracket;        /* Highest numbered group */
-   pcre_uint16 top_backref;
+   pcre_uint16 top_backref;        /* Highest numbered back reference */
-   pcre_uint16 first_byte;
+   pcre_uint16 first_char;         /* Starting character */
-   pcre_uint16 req_byte;
+   pcre_uint16 req_char;           /* This character must be seen */
    pcre_uint16 name_table_offset;  /* Offset to name table that follows */
    pcre_uint16 name_entry_size;    /* Size of any name items */
    pcre_uint16 name_count;         /* Number of name items */
    pcre_uint16 ref_count;          /* Reference count */
+   const pcre_uint8 *tables;       /* Pointer to tables or NULL for std */
+   const pcre_uint8 *nullpad;      /* NULL padding */
+ } real_pcre8_or_16;
-   const unsigned char *tables;    /* Pointer to tables or NULL for std */
+ typedef struct real_pcre8_or_16 real_pcre;
-   const unsigned char *nullpad;   /* NULL padding */
+ typedef struct real_pcre8_or_16 real_pcre16;
- } real_pcre;
+ typedef struct real_pcre32 {
+   pcre_uint32 magic_number;
+   pcre_uint32 size;               /* Total that was malloced */
+   pcre_uint32 options;            /* Public options */
+   pcre_uint16 flags;              /* Private flags */
+   pcre_uint16 max_lookbehind;     /* Longest lookbehind (characters) */
+   pcre_uint16 top_bracket;        /* Highest numbered group */
+   pcre_uint16 top_backref;        /* Highest numbered back reference */
+   pcre_uint32 first_char;         /* Starting character */
+   pcre_uint32 req_char;           /* This character must be seen */
+   pcre_uint16 name_table_offset;  /* Offset to name table that follows */
+   pcre_uint16 name_entry_size;    /* Size of any name items */
+   pcre_uint16 name_count;         /* Number of name items */
+   pcre_uint16 ref_count;          /* Reference count */
+   pcre_uint16 dummy1;             /* for later expansion */
+   pcre_uint16 dummy2;             /* for later expansion */
+   const pcre_uint8 *tables;       /* Pointer to tables or NULL for std */
+   void *nullpad;                  /* for later expansion */
+ } real_pcre32;
+ /* Assert that the size of REAL_PCRE is divisible by 8 */
+ typedef int __assert_real_pcre_size_divisible_8[(sizeof(REAL_PCRE) % 8) == 0 ? 1 : -1];
+ /* Needed in pcretest to access some fields in the real_pcre* structures
+  * directly. They're unified for 8/16/32 bits since the structs only differ
+  * after these fields; if that ever changes, need to fork those defines into
+  * 8/16 and 32 bit versions. */
+ #define REAL_PCRE_MAGIC(re)     (((REAL_PCRE*)re)->magic_number)
+ #define REAL_PCRE_SIZE(re)      (((REAL_PCRE*)re)->size)
+ #define REAL_PCRE_OPTIONS(re)   (((REAL_PCRE*)re)->options)
+ #define REAL_PCRE_FLAGS(re)     (((REAL_PCRE*)re)->flags)
  /* The format of the block used to store data from pcre_study(). The same
  remark (see NOTE above) about extending this structure applies. */
  typedef struct pcre_study_data {
    pcre_uint32 size;               /* Total that was malloced */
-   pcre_uint32 options;
+   pcre_uint32 flags;              /* Private flags */
-   uschar start_bits[32];
+   pcre_uint8 start_bits[32];      /* Starting char bits */
+   pcre_uint32 minlength;          /* Minimum subject length */
  } pcre_study_data;
+ /* Structure for building a chain of open capturing subpatterns during
+ compiling, so that instructions to close them can be compiled when (*ACCEPT) is
+ encountered. This is also used to identify subpatterns that contain recursive
+ back references to themselves, so that they can be made atomic. */
+ typedef struct open_capitem {
+   struct open_capitem *next;    /* Chain link */
+   pcre_uint16 number;           /* Capture number */
+   pcre_uint16 flag;             /* Set TRUE if recursive back ref */
+ } open_capitem;
  /* Structure for passing "static" information around between the functions
  doing the compiling, so that they are thread-safe. */
  typedef struct compile_data {
-   const uschar *lcc;            /* Points to lower casing table */
+   const pcre_uint8 *lcc;            /* Points to lower casing table */
-   const uschar *fcc;            /* Points to case-flipping table */
+   const pcre_uint8 *fcc;            /* Points to case-flipping table */
-   const uschar *cbits;          /* Points to character type table */
+   const pcre_uint8 *cbits;          /* Points to character type table */
-   const uschar *ctypes;         /* Points to table of type maps */
+   const pcre_uint8 *ctypes;         /* Points to table of type maps */
-   const uschar *start_workspace;/* The start of working space */
+   const pcre_uchar *start_workspace;/* The start of working space */
-   const uschar *start_code;     /* The start of the compiled code */
+   const pcre_uchar *start_code;     /* The start of the compiled code */
-   const uschar *start_pattern;  /* The start of the pattern */
+   const pcre_uchar *start_pattern;  /* The start of the pattern */
-   const uschar *end_pattern;    /* The end of the pattern */
+   const pcre_uchar *end_pattern;    /* The end of the pattern */
-   uschar *hwm;                  /* High watermark of workspace */
+   open_capitem *open_caps;          /* Chain of open capture items */
-   uschar *name_table;           /* The name/number table */
+   pcre_uchar *hwm;                  /* High watermark of workspace */
-   int  names_found;             /* Number of entries so far */
+   pcre_uchar *name_table;           /* The name/number table */
-   int  name_entry_size;         /* Size of each entry */
+   int  names_found;                 /* Number of entries so far */
-   int  bracount;                /* Count of capturing parens as we compile */
+   int  name_entry_size;             /* Size of each entry */
-   int  final_bracount;          /* Saved value after first pass */
+   int  workspace_size;              /* Size of workspace */
-   int  top_backref;             /* Maximum back reference */
+   int  bracount;                    /* Count of capturing parens as we compile */
-   unsigned int backref_map;     /* Bitmap of low back refs */
+   int  final_bracount;              /* Saved value after first pass */
-   int  external_options;        /* External (initial) options */
+   int  max_lookbehind;              /* Maximum lookbehind (characters) */
-   int  external_flags;          /* External flag bits to be set */
+   int  top_backref;                 /* Maximum back reference */
-   int  req_varyopt;             /* "After variable item" flag for reqbyte */
+   unsigned int backref_map;         /* Bitmap of low back refs */
-   BOOL had_accept;              /* (*ACCEPT) encountered */
+   int  assert_depth;                /* Depth of nested assertions */
-   int  nltype;                  /* Newline type */
+   int  external_options;            /* External (initial) options */
-   int  nllen;                   /* Newline string length */
+   int  external_flags;              /* External flag bits to be set */
-   uschar nl[4];                 /* Newline string when fixed length */
+   int  req_varyopt;                 /* "After variable item" flag for reqbyte */
+   BOOL had_accept;                  /* (*ACCEPT) encountered */
+   BOOL had_pruneorskip;             /* (*PRUNE) or (*SKIP) encountered */
+   BOOL check_lookbehind;            /* Lookbehinds need later checking */
+   int  nltype;                      /* Newline type */
+   int  nllen;                       /* Newline string length */
+   pcre_uchar nl[4];                 /* Newline string when fixed length */
  } compile_data;
  /* Structure for maintaining a chain of pointers to the currently incomplete
- branches, for testing for left recursion. */
+ branches, for testing for left recursion while compiling. */
  typedef struct branch_chain {
    struct branch_chain *outer;
-   uschar *current;
+   pcre_uchar *current_branch;
  } branch_chain;
  /* Structure for items in a linked list that represents an explicit recursive
- call within the pattern. */
+ call within the pattern; used by pcre_exec(). */
  typedef struct recursion_info {
    struct recursion_info *prevrec; /* Previous recursion record (or NULL) */
-   int group_num;                /* Number of group that was called */
+   int group_num;                  /* Number of group that was called */
-   const uschar *after_call;     /* "Return value": points after the call in the expr */
+   int *offset_save;               /* Pointer to start of saved offsets */
-   USPTR save_start;             /* Old value of mstart */
+   int saved_max;                  /* Number of saved offsets */
-   int *offset_save;             /* Pointer to start of saved offsets */
+   PCRE_PUCHAR subject_position;   /* Position at start of recursion */
-   int saved_max;                /* Number of saved offsets */
  } recursion_info;
+ /* A similar structure for pcre_dfa_exec(). */
+ typedef struct dfa_recursion_info {
+   struct dfa_recursion_info *prevrec;
+   int group_num;
+   PCRE_PUCHAR subject_position;
+ } dfa_recursion_info;
  /* Structure for building a chain of data for holding the values of the subject
  pointer at the start of each subpattern, so as to detect when an empty string
- has been matched by a subpattern - to break infinite loops. */
+ has been matched by a subpattern - to break infinite loops; used by
+ pcre_exec(). */
  typedef struct eptrblock {
    struct eptrblock *epb_prev;
-   USPTR epb_saved_eptr;
+   PCRE_PUCHAR epb_saved_eptr;
  } eptrblock;
-Line 1007 
 typedef struct match_data {
+Line 2375 
 typedef struct match_data {
    unsigned long int match_call_count;      /* As it says */
    unsigned long int match_limit;           /* As it says */
    unsigned long int match_limit_recursion; /* As it says */
-   int   *offset_vector;         /* Offset vector */
+   int   *offset_vector;           /* Offset vector */
-   int    offset_end;            /* One past the end */
+   int    offset_end;              /* One past the end */
-   int    offset_max;            /* The maximum usable for return data */
+   int    offset_max;              /* The maximum usable for return data */
-   int    nltype;                /* Newline type */
+   int    nltype;                  /* Newline type */
-   int    nllen;                 /* Newline string length */
+   int    nllen;                   /* Newline string length */
-   uschar nl[4];                 /* Newline string when fixed */
+   int    name_count;              /* Number of names in name table */
-   const uschar *lcc;            /* Points to lower casing table */
+   int    name_entry_size;         /* Size of entry in names table */
-   const uschar *ctypes;         /* Points to table of type maps */
+   pcre_uchar *name_table;         /* Table of names */
-   BOOL   offset_overflow;       /* Set if too many extractions */
+   pcre_uchar nl[4];               /* Newline string when fixed */
-   BOOL   notbol;                /* NOTBOL flag */
+   const  pcre_uint8 *lcc;         /* Points to lower casing table */
-   BOOL   noteol;                /* NOTEOL flag */
+   const  pcre_uint8 *fcc;         /* Points to case-flipping table */
-   BOOL   utf8;                  /* UTF8 flag */
+   const  pcre_uint8 *ctypes;      /* Points to table of type maps */
-   BOOL   jscript_compat;        /* JAVASCRIPT_COMPAT flag */
+   BOOL   offset_overflow;         /* Set if too many extractions */
-   BOOL   endonly;               /* Dollar not before final \n */
+   BOOL   notbol;                  /* NOTBOL flag */
-   BOOL   notempty;              /* Empty string match not wanted */
+   BOOL   noteol;                  /* NOTEOL flag */
-   BOOL   partial;               /* PARTIAL flag */
+   BOOL   utf;                     /* UTF-8 / UTF-16 flag */
-   BOOL   hitend;                /* Hit the end of the subject at some point */
+   BOOL   jscript_compat;          /* JAVASCRIPT_COMPAT flag */
-   BOOL   bsr_anycrlf;           /* \R is just any CRLF, not full Unicode */
+   BOOL   use_ucp;                 /* PCRE_UCP flag */
-   const uschar *start_code;     /* For use when recursing */
+   BOOL   endonly;                 /* Dollar not before final \n */
-   USPTR  start_subject;         /* Start of the subject string */
+   BOOL   notempty;                /* Empty string match not wanted */
-   USPTR  end_subject;           /* End of the subject string */
+   BOOL   notempty_atstart;        /* Empty string match at start not wanted */
-   USPTR  start_match_ptr;       /* Start of matched string */
+   BOOL   hitend;                  /* Hit the end of the subject at some point */
-   USPTR  end_match_ptr;         /* Subject position at end match */
+   BOOL   bsr_anycrlf;             /* \R is just any CRLF, not full Unicode */
-   int    end_offset_top;        /* Highwater mark at end of match */
+   BOOL   hasthen;                 /* Pattern contains (*THEN) */
-   int    capture_last;          /* Most recent capture number */
+   BOOL   ignore_skip_arg;         /* For re-run when SKIP name not found */
-   int    start_offset;          /* The start offset value */
+   const  pcre_uchar *start_code;  /* For use when recursing */
-   eptrblock *eptrchain;         /* Chain of eptrblocks for tail recursions */
+   PCRE_PUCHAR start_subject;      /* Start of the subject string */
-   int    eptrn;                 /* Next free eptrblock */
+   PCRE_PUCHAR end_subject;        /* End of the subject string */
-   recursion_info *recursive;    /* Linked list of recursion data */
+   PCRE_PUCHAR start_match_ptr;    /* Start of matched string */
-   void  *callout_data;          /* To pass back to callouts */
+   PCRE_PUCHAR end_match_ptr;      /* Subject position at end match */
+   PCRE_PUCHAR start_used_ptr;     /* Earliest consulted character */
+   int    partial;                 /* PARTIAL options */
+   int    end_offset_top;          /* Highwater mark at end of match */
+   int    capture_last;            /* Most recent capture number */
+   int    start_offset;            /* The start offset value */
+   int    match_function_type;     /* Set for certain special calls of MATCH() */
+   eptrblock *eptrchain;           /* Chain of eptrblocks for tail recursions */
+   int    eptrn;                   /* Next free eptrblock */
+   recursion_info *recursive;      /* Linked list of recursion data */
+   void  *callout_data;            /* To pass back to callouts */
+   const  pcre_uchar *mark;        /* Mark pointer to pass back on success */
+   const  pcre_uchar *nomatch_mark;/* Mark pointer to pass back on failure */
+   const  pcre_uchar *once_target; /* Where to back up to for atomic groups */
+ #ifdef NO_RECURSE
+   void  *match_frames_base;       /* For remembering malloc'd frames */
+ #endif
  } match_data;
  /* A similar structure is used for the same purpose by the DFA matching
  functions. */
  typedef struct dfa_match_data {
-   const uschar *start_code;     /* Start of the compiled pattern */
+   const pcre_uchar *start_code;     /* Start of the compiled pattern */
-   const uschar *start_subject;  /* Start of the subject string */
+   const pcre_uchar *start_subject ; /* Start of the subject string */
-   const uschar *end_subject;    /* End of subject string */
+   const pcre_uchar *end_subject;    /* End of subject string */
-   const uschar *tables;         /* Character tables */
+   const pcre_uchar *start_used_ptr; /* Earliest consulted character */
-   int   moptions;               /* Match options */
+   const pcre_uint8 *tables;         /* Character tables */
-   int   poptions;               /* Pattern options */
+   int   start_offset;               /* The start offset value */
-   int    nltype;                /* Newline type */
+   int   moptions;                   /* Match options */
-   int    nllen;                 /* Newline string length */
+   int   poptions;                   /* Pattern options */
-   uschar nl[4];                 /* Newline string when fixed */
+   int   nltype;                     /* Newline type */
-   void  *callout_data;          /* To pass back to callouts */
+   int   nllen;                      /* Newline string length */
+   pcre_uchar nl[4];                 /* Newline string when fixed */
+   void *callout_data;               /* To pass back to callouts */
+   dfa_recursion_info *recursive;    /* Linked list of recursion data */
  } dfa_match_data;
  /* Bit definitions for entries in the pcre_ctypes table. */
-Line 1088 
 total length. */
+Line 2475 
 total length. */
  #define ctypes_offset (cbits_offset + cbit_length)
  #define tables_length (ctypes_offset + 256)
+ /* Internal function and data prefixes. */
+ #if defined COMPILE_PCRE8
+ #ifndef PUBL
+ #define PUBL(name) pcre_##name
+ #endif
+ #ifndef PRIV
+ #define PRIV(name) _pcre_##name
+ #endif
+ #elif defined COMPILE_PCRE16
+ #ifndef PUBL
+ #define PUBL(name) pcre16_##name
+ #endif
+ #ifndef PRIV
+ #define PRIV(name) _pcre16_##name
+ #endif
+ #elif defined COMPILE_PCRE32
+ #ifndef PUBL
+ #define PUBL(name) pcre32_##name
+ #endif
+ #ifndef PRIV
+ #define PRIV(name) _pcre32_##name
+ #endif
+ #else
+ #error Unsupported compiling mode
+ #endif /* COMPILE_PCRE[8|16|32] */
  /* Layout of the UCP type table that translates property names into types and
  codes. Each entry used to point directly to a name, but to reduce the number of
  relocations in shared libraries, it now has an offset into a single string
-Line 1105 
 of the exported public functions. They h
+Line 2519 
 of the exported public functions. They h
  but are not part of the PCRE public API. The data for these tables is in the
  pcre_tables.c module. */
- extern const int    _pcre_utf8_table1[];
+ #ifdef COMPILE_PCRE8
- extern const int    _pcre_utf8_table2[];
+ extern const int            PRIV(utf8_table1)[];
- extern const int    _pcre_utf8_table3[];
+ extern const int            PRIV(utf8_table1_size);
- extern const uschar _pcre_utf8_table4[];
+ extern const int            PRIV(utf8_table2)[];
+ extern const int            PRIV(utf8_table3)[];
- extern const int    _pcre_utf8_table1_size;
+ extern const pcre_uint8     PRIV(utf8_table4)[];
+ #endif /* COMPILE_PCRE8 */
- extern const char   _pcre_utt_names[];
- extern const ucp_type_table _pcre_utt[];
+ extern const char           PRIV(utt_names)[];
- extern const int _pcre_utt_size;
+ extern const ucp_type_table PRIV(utt)[];
+ extern const int            PRIV(utt_size);
- extern const uschar _pcre_default_tables[];
+ extern const pcre_uint8     PRIV(OP_lengths)[];
+ extern const pcre_uint8     PRIV(default_tables)[];
- extern const uschar _pcre_OP_lengths[];
+ extern const pcre_uint32    PRIV(hspace_list)[];
+ extern const pcre_uint32    PRIV(vspace_list)[];
  /* Internal shared functions. These are functions that are used by more than
  one of the exported public functions. They have to be "external" in the C
  sense, but are not part of the PCRE public API. */
- extern BOOL         _pcre_is_newline(const uschar *, int, const uschar *,
+ /* String comparison functions. */
-                       int *, BOOL);
+ #if defined COMPILE_PCRE8
- extern int          _pcre_ord2utf8(int, uschar *);
- extern real_pcre   *_pcre_try_flipped(const real_pcre *, real_pcre *,
-                       const pcre_study_data *, pcre_study_data *);
- extern int          _pcre_valid_utf8(const uschar *, int);
- extern BOOL         _pcre_was_newline(const uschar *, int, const uschar *,
-                       int *, BOOL);
- extern BOOL         _pcre_xclass(int, const uschar *);
+ #define STRCMP_UC_UC(str1, str2) \
+   strcmp((char *)(str1), (char *)(str2))
+ #define STRCMP_UC_C8(str1, str2) \
+   strcmp((char *)(str1), (str2))
+ #define STRNCMP_UC_UC(str1, str2, num) \
+   strncmp((char *)(str1), (char *)(str2), (num))
+ #define STRNCMP_UC_C8(str1, str2, num) \
+   strncmp((char *)(str1), (str2), (num))
+ #define STRLEN_UC(str) strlen((const char *)str)
+ #elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+ extern int               PRIV(strcmp_uc_uc)(const pcre_uchar *,
+                            const pcre_uchar *);
+ extern int               PRIV(strcmp_uc_c8)(const pcre_uchar *,
+                            const char *);
+ extern int               PRIV(strncmp_uc_uc)(const pcre_uchar *,
+                            const pcre_uchar *, unsigned int num);
+ extern int               PRIV(strncmp_uc_c8)(const pcre_uchar *,
+                            const char *, unsigned int num);
+ extern unsigned int      PRIV(strlen_uc)(const pcre_uchar *str);
+ #define STRCMP_UC_UC(str1, str2) \
+   PRIV(strcmp_uc_uc)((str1), (str2))
+ #define STRCMP_UC_C8(str1, str2) \
+   PRIV(strcmp_uc_c8)((str1), (str2))
+ #define STRNCMP_UC_UC(str1, str2, num) \
+   PRIV(strncmp_uc_uc)((str1), (str2), (num))
+ #define STRNCMP_UC_C8(str1, str2, num) \
+   PRIV(strncmp_uc_c8)((str1), (str2), (num))
+ #define STRLEN_UC(str) PRIV(strlen_uc)(str)
+ #endif /* COMPILE_PCRE[8|16|32] */
+ extern const pcre_uchar *PRIV(find_bracket)(const pcre_uchar *, BOOL, int);
+ extern BOOL              PRIV(is_newline)(PCRE_PUCHAR, int, PCRE_PUCHAR,
+                            int *, BOOL);
+ extern int               PRIV(ord2utf)(pcre_uint32, pcre_uchar *);
+ extern int               PRIV(valid_utf)(PCRE_PUCHAR, int, int *);
+ extern BOOL              PRIV(was_newline)(PCRE_PUCHAR, int, PCRE_PUCHAR,
+                            int *, BOOL);
+ extern BOOL              PRIV(xclass)(pcre_uint32, const pcre_uchar *, BOOL);
+ #ifdef SUPPORT_JIT
+ extern void              PRIV(jit_compile)(const REAL_PCRE *,
+                            PUBL(extra) *, int);
+ extern int               PRIV(jit_exec)(const REAL_PCRE *, const PUBL(extra) *,
+                            const pcre_uchar *, int, int, int, int *, int);
+ extern void              PRIV(jit_free)(void *);
+ extern int               PRIV(jit_get_size)(void *);
+ extern const char*       PRIV(jit_get_target)(void);
+ #endif
  /* Unicode character database (UCD) */
  typedef struct {
-   uschar script;
+   pcre_uint8 script;     /* ucp_Arabic, etc. */
-   uschar chartype;
+   pcre_uint8 chartype;   /* ucp_Cc, etc. (general categories) */
-   pcre_int32 other_case;
+   pcre_uint8 gbprop;     /* ucp_gbControl, etc. (grapheme break property) */
+   pcre_uint8 caseset;    /* offset to multichar other cases or zero */
+   pcre_int32 other_case; /* offset to other case, or zero if none */
  } ucd_record;
- extern const ucd_record  _pcre_ucd_records[];
+ extern const pcre_uint32 PRIV(ucd_caseless_sets)[];
- extern const uschar      _pcre_ucd_stage1[];
+ extern const ucd_record  PRIV(ucd_records)[];
- extern const pcre_uint16 _pcre_ucd_stage2[];
+ extern const pcre_uint8  PRIV(ucd_stage1)[];
- extern const int         _pcre_ucp_gentype[];
+ extern const pcre_uint16 PRIV(ucd_stage2)[];
+ extern const int         PRIV(ucp_gentype)[];
+ extern const pcre_uint32 PRIV(ucp_gbtable)[];
+ #ifdef SUPPORT_JIT
+ extern const int         PRIV(ucp_typerange)[];
+ #endif
+ #ifdef SUPPORT_UCP
  /* UCD access macros */
  #define UCD_BLOCK_SIZE 128
- #define GET_UCD(ch) (_pcre_ucd_records + \
+ #define GET_UCD(ch) (PRIV(ucd_records) + \
-         _pcre_ucd_stage2[_pcre_ucd_stage1[(ch) / UCD_BLOCK_SIZE] * \
+         PRIV(ucd_stage2)[PRIV(ucd_stage1)[(ch) / UCD_BLOCK_SIZE] * \
-         UCD_BLOCK_SIZE + ch % UCD_BLOCK_SIZE])
+         UCD_BLOCK_SIZE + (ch) % UCD_BLOCK_SIZE])
- #define UCD_CHARTYPE(ch)  GET_UCD(ch)->chartype
+ #define UCD_CHARTYPE(ch)    GET_UCD(ch)->chartype
- #define UCD_SCRIPT(ch)    GET_UCD(ch)->script
+ #define UCD_SCRIPT(ch)      GET_UCD(ch)->script
- #define UCD_CATEGORY(ch)  _pcre_ucp_gentype[UCD_CHARTYPE(ch)]
+ #define UCD_CATEGORY(ch)    PRIV(ucp_gentype)[UCD_CHARTYPE(ch)]
- #define UCD_OTHERCASE(ch) (ch + GET_UCD(ch)->other_case)
+ #define UCD_GRAPHBREAK(ch)  GET_UCD(ch)->gbprop
+ #define UCD_CASESET(ch)     GET_UCD(ch)->caseset
+ #define UCD_OTHERCASE(ch)   (ch + GET_UCD(ch)->other_case)
+ #endif /* SUPPORT_UCP */
  #endif

 Legend:



Removed from v.351
 


changed lines


 
Added in v.1057
 Legend:



Removed from v.351
 


changed lines


 
Added in v.1057
-Removed from v.351
+Added in v.1057

	ViewVC Help
Powered by ViewVC 1.1.5