/[pcre]/code/trunk/pcre_compile.c

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 849 by ph10,
Wed Jan  4 17:02:01 2012 UTC
+revision 1538 by ph10,
Sun Mar 29 11:22:24 2015 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2012 University of Cambridge
+            Copyright (c) 1997-2014 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 47 
 supporting internal functions that are n
  #endif
  #define NLBLOCK cd             /* Block containing newline information */
- #define PSSTART start_pattern  /* Field containing processed string start */
+ #define PSSTART start_pattern  /* Field containing pattern start */
- #define PSEND   end_pattern    /* Field containing processed string end */
+ #define PSEND   end_pattern    /* Field containing pattern end */
  #include "pcre_internal.h"
- /* When PCRE_DEBUG is defined, we need the pcre(16)_printint() function, which
+ /* When PCRE_DEBUG is defined, we need the pcre(16|32)_printint() function, which
  is also used by pcretest. PCRE_DEBUG is not defined when building a production
  library. We do not need to select pcre16_printint.c specially, because the
  COMPILE_PCREx macro will already be appropriately set. */
 Line 68 
 COMPILE_PCREx macro will already be appr
  /* Macro for setting individual bits in class bitmaps. */
- #define SETBIT(a,b) a[b/8] |= (1 << (b%8))
+ #define SETBIT(a,b) a[(b)/8] |= (1 << ((b)&7))
  /* Maximum length value to check against when making sure that the integer that
  holds the compiled pattern length does not overflow. We make it a bit less than
 Line 77 
 to check them every time. */
  #define OFLOW_MAX (INT_MAX - 20)
+ /* Definitions to allow mutual recursion */
+ static int
+   add_list_to_class(pcre_uint8 *, pcre_uchar **, int, compile_data *,
+     const pcre_uint32 *, unsigned int);
+ static BOOL
+   compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL, int, int,
+     pcre_uint32 *, pcre_int32 *, pcre_uint32 *, pcre_int32 *, branch_chain *,
+     compile_data *, int *);
  /*************************************************
  *      Code parameters and static tables         *
-Line 103 
 kicks in at the same number of forward r
+Line 115 
 kicks in at the same number of forward r
  #define COMPILE_WORK_SIZE (2048*LINK_SIZE)
  #define COMPILE_WORK_SIZE_MAX (100*COMPILE_WORK_SIZE)
+ /* This value determines the size of the initial vector that is used for
+ remembering named groups during the pre-compile. It is allocated on the stack,
+ but if it is too small, it is expanded using malloc(), in a similar way to the
+ workspace. The value is the number of slots in the list. */
+ #define NAMED_GROUP_LIST_SIZE  20
  /* The overrun tests check for a slightly smaller size so that they detect the
  overrun before it actually does run off the end of the data block. */
-Line 110 
 overrun before it actually does run off
+Line 129 
 overrun before it actually does run off
  /* Private flags added to firstchar and reqchar. */
- #define REQ_CASELESS   0x10000000l      /* Indicates caselessness */
+ #define REQ_CASELESS    (1 << 0)        /* Indicates caselessness */
- #define REQ_VARY       0x20000000l      /* Reqchar followed non-literal item */
+ #define REQ_VARY        (1 << 1)        /* Reqchar followed non-literal item */
+ /* Negative values for the firstchar and reqchar flags */
+ #define REQ_UNSET       (-2)
+ #define REQ_NONE        (-1)
  /* Repeated character flags. */
-Line 238 
 static const verbitem verbs[] = {
+Line 260 
 static const verbitem verbs[] = {
  static const int verbcount = sizeof(verbs)/sizeof(verbitem);
+ /* Substitutes for [[:<:]] and [[:>:]], which mean start and end of word in
+ another regex library. */
+ static const pcre_uchar sub_start_of_word[] = {
+   CHAR_BACKSLASH, CHAR_b, CHAR_LEFT_PARENTHESIS, CHAR_QUESTION_MARK,
+   CHAR_EQUALS_SIGN, CHAR_BACKSLASH, CHAR_w, CHAR_RIGHT_PARENTHESIS, '\0' };
+ static const pcre_uchar sub_end_of_word[] = {
+   CHAR_BACKSLASH, CHAR_b, CHAR_LEFT_PARENTHESIS, CHAR_QUESTION_MARK,
+   CHAR_LESS_THAN_SIGN, CHAR_EQUALS_SIGN, CHAR_BACKSLASH, CHAR_w,
+   CHAR_RIGHT_PARENTHESIS, '\0' };
  /* Tables of names of POSIX character classes and their lengths. The names are
  now all in a single string, to reduce the number of relocations when a shared
  library is dynamically loaded. The list of lengths is terminated by a zero
  length entry. The first three must be alpha, lower, upper, as this is assumed
- for handling case independence. */
+ for handling case independence. The indices for graph, print, and punct are
+ needed, so identify them. */
  static const char posix_names[] =
    STRING_alpha0 STRING_lower0 STRING_upper0 STRING_alnum0
-Line 253 
 static const char posix_names[] =
+Line 289 
 static const char posix_names[] =
  static const pcre_uint8 posix_name_lengths[] = {
 , 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
+ #define PC_GRAPH  8
+ #define PC_PRINT  9
+ #define PC_PUNCT 10
  /* Table of class bit maps for each POSIX class. Each class is formed from a
  base map, with an optional addition or removal of another map. Then, for some
  classes, there is some additional tweaking: for [:blank:] the vertical space
-Line 280 
 static const int posix_class_maps[] = {
+Line 321 
 static const int posix_class_maps[] = {
    cbit_xdigit,-1,          0              /* xdigit */
  };
- /* Table of substitutes for \d etc when PCRE_UCP is set. The POSIX class
+ /* Table of substitutes for \d etc when PCRE_UCP is set. They are replaced by
- substitutes must be in the order of the names, defined above, and there are
+ Unicode property escapes. */
- both positive and negative cases. NULL means no substitute. */
  #ifdef SUPPORT_UCP
  static const pcre_uchar string_PNd[]  = {
-Line 307 
 static const pcre_uchar string_pXwd[] =
+Line 347 
 static const pcre_uchar string_pXwd[] =
  static const pcre_uchar *substitutes[] = {
    string_PNd,           /* \D */
    string_pNd,           /* \d */
-   string_PXsp,          /* \S */       /* NOTE: Xsp is Perl space */
+   string_PXsp,          /* \S */   /* Xsp is Perl space, but from 8.34, Perl */
-   string_pXsp,          /* \s */
+   string_pXsp,          /* \s */   /* space and POSIX space are the same. */
    string_PXwd,          /* \W */
    string_pXwd           /* \w */
  };
+ /* The POSIX class substitutes must be in the order of the POSIX class names,
+ defined above, and there are both positive and negative cases. NULL means no
+ general substitute of a Unicode property escape (\p or \P). However, for some
+ POSIX classes (e.g. graph, print, punct) a special property code is compiled
+ directly. */
  static const pcre_uchar string_pL[] =   {
    CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
    CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };
-Line 360 
 static const pcre_uchar *posix_substitut
+Line 406 
 static const pcre_uchar *posix_substitut
    NULL,                 /* graph */
    NULL,                 /* print */
    NULL,                 /* punct */
-   string_pXps,          /* space */    /* NOTE: Xps is POSIX space */
+   string_pXps,          /* space */   /* Xps is POSIX space, but from 8.34 */
-   string_pXwd,          /* word */
+   string_pXwd,          /* word  */   /* Perl and POSIX space are the same */
    NULL,                 /* xdigit */
    /* Negated cases */
    string_PL,            /* ^alpha */
-Line 375 
 static const pcre_uchar *posix_substitut
+Line 421 
 static const pcre_uchar *posix_substitut
    NULL,                 /* ^graph */
    NULL,                 /* ^print */
    NULL,                 /* ^punct */
-   string_PXps,          /* ^space */   /* NOTE: Xps is POSIX space */
+   string_PXps,          /* ^space */  /* Xps is POSIX space, but from 8.34 */
-   string_PXwd,          /* ^word */
+   string_PXwd,          /* ^word */   /* Perl and POSIX space are the same */
    NULL                  /* ^xdigit */
  };
  #define POSIX_SUBSIZE (sizeof(posix_substitutes) / sizeof(pcre_uchar *))
-Line 440 
 static const char error_texts[] =
+Line 486 
 static const char error_texts[] =
    "POSIX collating elements are not supported\0"
    "this version of PCRE is compiled without UTF support\0"
    "spare error\0"  /** DEAD **/
-   "character value in \\x{...} sequence is too large\0"
+   "character value in \\x{} or \\o{} is too large\0"
    /* 35 */
    "invalid condition (?(0)\0"
    "\\C not allowed in lookbehind assertion\0"
-Line 472 
 static const char error_texts[] =
+Line 518 
 static const char error_texts[] =
    "a numbered reference must not be zero\0"
    "an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)\0"
    /* 60 */
-   "(*VERB) not recognized\0"
+   "(*VERB) not recognized or malformed\0"
    "number is too big\0"
    "subpattern name expected\0"
    "digit expected after (?+\0"
-Line 488 
 static const char error_texts[] =
+Line 534 
 static const char error_texts[] =
    "\\N is not supported in a class\0"
    "too many forward references\0"
    "disallowed Unicode code point (>= 0xd800 && <= 0xdfff)\0"
    "invalid UTF-16 string\0"
+   /* 75 */
+   "name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)\0"
+   "character value in \\u.... sequence is too large\0"
+   "invalid UTF-32 string\0"
+   "setting UTF is disabled by the application\0"
+   "non-hex character in \\x{} (closing brace missing?)\0"
+   /* 80 */
+   "non-octal character in \\o{} (closing brace missing?)\0"
+   "missing opening brace after \\o\0"
+   "parentheses are too deeply nested\0"
+   "invalid range in character class\0"
+   "group name must start with a non-digit\0"
+   /* 85 */
+   "parentheses are too deeply nested (stack check)\0"
+   "digits missing in \\x{} or \\o{}\0"
    ;
  /* Table to identify digits and hex digits. This is used when compiling
-Line 628 
 static const pcre_uint8 ebcdic_chartab[]
+Line 689 
 static const pcre_uint8 ebcdic_chartab[]
  #endif
- /* Definition to allow mutual recursion */
+ /* This table is used to check whether auto-possessification is possible
+ between adjacent character-type opcodes. The left-hand (repeated) opcode is
+ used to select the row, and the right-hand opcode is use to select the column.
+ A value of 1 means that auto-possessification is OK. For example, the second
+ value in the first row means that \D+\d can be turned into \D++\d.
+ The Unicode property types (\P and \p) have to be present to fill out the table
+ because of what their opcode values are, but the table values should always be
+ zero because property types are handled separately in the code. The last four
+ columns apply to items that cannot be repeated, so there is no need to have
+ rows for them. Note that OP_DIGIT etc. are generated only when PCRE_UCP is
+ *not* set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
+ #define APTROWS (LAST_AUTOTAB_LEFT_OP - FIRST_AUTOTAB_OP + 1)
+ #define APTCOLS (LAST_AUTOTAB_RIGHT_OP - FIRST_AUTOTAB_OP + 1)
+ static const pcre_uint8 autoposstab[APTROWS][APTCOLS] = {
+ /* \D \d \S \s \W \w  . .+ \C \P \p \R \H \h \V \v \X \Z \z  $ $M */
+   { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \D */
+   { 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 },  /* \d */
+   { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 },  /* \S */
+   { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \s */
+   { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \W */
+   { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 },  /* \w */
+   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* .  */
+   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* .+ */
+   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \C */
+   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* \P */
+   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* \p */
+   { 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 },  /* \R */
+   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 },  /* \H */
+   { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0 },  /* \h */
+   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0 },  /* \V */
+   { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0 },  /* \v */
+   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }   /* \X */
+ };
- static BOOL
+ /* This table is used to check whether auto-possessification is possible
-   compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL, int, int,
+ between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP). The
-     int *, int *, branch_chain *, compile_data *, int *);
+ left-hand (repeated) opcode is used to select the row, and the right-hand
+ opcode is used to select the column. The values are as follows:
+  Always return FALSE (never auto-possessify)
+  Character groups are distinct (possessify if both are OP_PROP)
+  Check character categories in the same group (general or particular)
+  TRUE if the two opcodes are not the same (PROP vs NOTPROP)
+  Check left general category vs right particular category
+  Check right general category vs left particular category
+  Left alphanum vs right general category
+  Left space vs right general category
+  Left word vs right general category
+  Right alphanum vs left general category
+  Right space vs left general category
+  Right word vs left general category
+  Left alphanum vs right particular category
+  Left space vs right particular category
+  Left word vs right particular category
+  Right alphanum vs left particular category
+  Right space vs left particular category
+  Right word vs left particular category
+ */
+ static const pcre_uint8 propposstab[PT_TABSIZE][PT_TABSIZE] = {
+ /* ANY LAMP GC  PC  SC ALNUM SPACE PXSPACE WORD CLIST UCNC */
+   { 0,  0,  0,  0,  0,    0,    0,      0,   0,    0,   0 },  /* PT_ANY */
+   { 0,  3,  0,  0,  0,    3,    1,      1,   0,    0,   0 },  /* PT_LAMP */
+   { 0,  0,  2,  4,  0,    9,   10,     10,  11,    0,   0 },  /* PT_GC */
+   { 0,  0,  5,  2,  0,   15,   16,     16,  17,    0,   0 },  /* PT_PC */
+   { 0,  0,  0,  0,  2,    0,    0,      0,   0,    0,   0 },  /* PT_SC */
+   { 0,  3,  6, 12,  0,    3,    1,      1,   0,    0,   0 },  /* PT_ALNUM */
+   { 0,  1,  7, 13,  0,    1,    3,      3,   1,    0,   0 },  /* PT_SPACE */
+   { 0,  1,  7, 13,  0,    1,    3,      3,   1,    0,   0 },  /* PT_PXSPACE */
+   { 0,  0,  8, 14,  0,    0,    1,      1,   3,    0,   0 },  /* PT_WORD */
+   { 0,  0,  0,  0,  0,    0,    0,      0,   0,    0,   0 },  /* PT_CLIST */
+   { 0,  0,  0,  0,  0,    0,    0,      0,   0,    0,   3 }   /* PT_UCNC */
+ };
+ /* This table is used to check whether auto-possessification is possible
+ between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP) when one
+ specifies a general category and the other specifies a particular category. The
+ row is selected by the general category and the column by the particular
+ category. The value is 1 if the particular category is not part of the general
+ category. */
+ static const pcre_uint8 catposstab[7][30] = {
+ /* Cc Cf Cn Co Cs Ll Lm Lo Lt Lu Mc Me Mn Nd Nl No Pc Pd Pe Pf Pi Po Ps Sc Sk Sm So Zl Zp Zs */
+   { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* C */
+   { 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* L */
+   { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* M */
+   { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* N */
+   { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 },  /* P */
+   { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 },  /* S */
+   { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 }   /* Z */
+ };
+ /* This table is used when checking ALNUM, (PX)SPACE, SPACE, and WORD against
+ a general or particular category. The properties in each row are those
+ that apply to the character set in question. Duplication means that a little
+ unnecessary work is done when checking, but this keeps things much simpler
+ because they can all use the same code. For more details see the comment where
+ this table is used.
+ Note: SPACE and PXSPACE used to be different because Perl excluded VT from
+ "space", but from Perl 5.18 it's included, so both categories are treated the
+ same here. */
+ static const pcre_uint8 posspropstab[3][4] = {
+   { ucp_L, ucp_N, ucp_N, ucp_Nl },  /* ALNUM, 3rd and 4th values redundant */
+   { ucp_Z, ucp_Z, ucp_C, ucp_Cc },  /* SPACE and PXSPACE, 2nd value redundant */
+   { ucp_L, ucp_N, ucp_P, ucp_Po }   /* WORD */
+ };
+ /* This table is used when converting repeating opcodes into possessified
+ versions as a result of an explicit possessive quantifier such as ++. A zero
+ value means there is no possessified version - in those cases the item in
+ question must be wrapped in ONCE brackets. The table is truncated at OP_CALLOUT
+ because all relevant opcodes are less than that. */
+ static const pcre_uint8 opcode_possessify[] = {
+, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 0 - 15  */
+, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 16 - 31 */
+,                       /* NOTI */
+   OP_POSSTAR, 0,           /* STAR, MINSTAR */
+   OP_POSPLUS, 0,           /* PLUS, MINPLUS */
+   OP_POSQUERY, 0,          /* QUERY, MINQUERY */
+   OP_POSUPTO, 0,           /* UPTO, MINUPTO */
+,                       /* EXACT */
+, 0, 0, 0,              /* POS{STAR,PLUS,QUERY,UPTO} */
+   OP_POSSTARI, 0,          /* STARI, MINSTARI */
+   OP_POSPLUSI, 0,          /* PLUSI, MINPLUSI */
+   OP_POSQUERYI, 0,         /* QUERYI, MINQUERYI */
+   OP_POSUPTOI, 0,          /* UPTOI, MINUPTOI */
+,                       /* EXACTI */
+, 0, 0, 0,              /* POS{STARI,PLUSI,QUERYI,UPTOI} */
+   OP_NOTPOSSTAR, 0,        /* NOTSTAR, NOTMINSTAR */
+   OP_NOTPOSPLUS, 0,        /* NOTPLUS, NOTMINPLUS */
+   OP_NOTPOSQUERY, 0,       /* NOTQUERY, NOTMINQUERY */
+   OP_NOTPOSUPTO, 0,        /* NOTUPTO, NOTMINUPTO */
+,                       /* NOTEXACT */
+, 0, 0, 0,              /* NOTPOS{STAR,PLUS,QUERY,UPTO} */
+   OP_NOTPOSSTARI, 0,       /* NOTSTARI, NOTMINSTARI */
+   OP_NOTPOSPLUSI, 0,       /* NOTPLUSI, NOTMINPLUSI */
+   OP_NOTPOSQUERYI, 0,      /* NOTQUERYI, NOTMINQUERYI */
+   OP_NOTPOSUPTOI, 0,       /* NOTUPTOI, NOTMINUPTOI */
+,                       /* NOTEXACTI */
+, 0, 0, 0,              /* NOTPOS{STARI,PLUSI,QUERYI,UPTOI} */
+   OP_TYPEPOSSTAR, 0,       /* TYPESTAR, TYPEMINSTAR */
+   OP_TYPEPOSPLUS, 0,       /* TYPEPLUS, TYPEMINPLUS */
+   OP_TYPEPOSQUERY, 0,      /* TYPEQUERY, TYPEMINQUERY */
+   OP_TYPEPOSUPTO, 0,       /* TYPEUPTO, TYPEMINUPTO */
+,                       /* TYPEEXACT */
+, 0, 0, 0,              /* TYPEPOS{STAR,PLUS,QUERY,UPTO} */
+   OP_CRPOSSTAR, 0,         /* CRSTAR, CRMINSTAR */
+   OP_CRPOSPLUS, 0,         /* CRPLUS, CRMINPLUS */
+   OP_CRPOSQUERY, 0,        /* CRQUERY, CRMINQUERY */
+   OP_CRPOSRANGE, 0,        /* CRRANGE, CRMINRANGE */
+, 0, 0, 0,              /* CRPOS{STAR,PLUS,QUERY,RANGE} */
+, 0, 0,                 /* CLASS, NCLASS, XCLASS */
+, 0,                    /* REF, REFI */
+, 0,                    /* DNREF, DNREFI */
+, 0                     /* RECURSE, CALLOUT */
+ };
-Line 655 
 find_error_text(int n)
+Line 886 
 find_error_text(int n)
  const char *s = error_texts;
  for (; n > 0; n--)
    {
-   while (*s++ != 0) {};
+   while (*s++ != CHAR_NULL) {};
-   if (*s == 0) return "Error text not found (please report)";
+   if (*s == CHAR_NULL) return "Error text not found (please report)";
    }
  return s;
  }
  /*************************************************
  *           Expand the workspace                 *
  *************************************************/
-Line 739 
 return (*p == CHAR_RIGHT_CURLY_BRACKET);
+Line 971 
 return (*p == CHAR_RIGHT_CURLY_BRACKET);
  *************************************************/
  /* This function is called when a \ has been encountered. It either returns a
- positive value for a simple escape such as \n, or a negative value which
+ positive value for a simple escape such as \n, or 0 for a data character which
- encodes one of the more complicated things such as \d. A backreference to group
+ will be placed in chptr. A backreference to group n is returned as negative n.
- n is returned as -(ESC_REF + n); ESC_REF is the highest ESC_xxx macro. When
+ When UTF-8 is enabled, a positive value greater than 255 may be returned in
- UTF-8 is enabled, a positive value greater than 255 may be returned. On entry,
+ chptr. On entry, ptr is pointing at the \. On exit, it is on the final
- ptr is pointing at the \. On exit, it is on the final character of the escape
+ character of the escape sequence.
- sequence.
  Arguments:
    ptrptr         points to the pattern position pointer
+   chptr          points to a returned data character
    errorcodeptr   points to the errorcode variable
    bracount       number of previous extracting brackets
    options        the options bits
    isclass        TRUE if inside a character class
- Returns:         zero or positive => a data character
+ Returns:         zero => a data character
-                  negative => a special escape sequence
+                  positive => a special escape sequence
+                  negative => a back reference
                   on error, errorcodeptr is set
  */
  static int
- check_escape(const pcre_uchar **ptrptr, int *errorcodeptr, int bracount,
+ check_escape(const pcre_uchar **ptrptr, pcre_uint32 *chptr, int *errorcodeptr,
-   int options, BOOL isclass)
+   int bracount, int options, BOOL isclass)
  {
  /* PCRE_UTF16 has the same value as PCRE_UTF8. */
  BOOL utf = (options & PCRE_UTF8) != 0;
  const pcre_uchar *ptr = *ptrptr + 1;
- pcre_int32 c;
+ pcre_uint32 c;
+ int escape = 0;
  int i;
  GETCHARINCTEST(c, ptr);           /* Get character value, increment pointer */
-Line 773 
 ptr--;                            /* Set
+Line 1007 
 ptr--;                            /* Set
  /* If backslash is at the end of the pattern, it's an error. */
- if (c == 0) *errorcodeptr = ERR1;
+ if (c == CHAR_NULL) *errorcodeptr = ERR1;
  /* Non-alphanumerics are literals. For digits or letters, do an initial lookup
  in a table. A non-zero result is something that can be returned immediately.
-Line 782 
 Otherwise further processing may be requ
+Line 1016 
 Otherwise further processing may be requ
  #ifndef EBCDIC  /* ASCII/UTF-8 coding */
  /* Not alphanumeric */
  else if (c < CHAR_0 || c > CHAR_z) {}
- else if ((i = escapes[c - CHAR_0]) != 0) c = i;
+ else if ((i = escapes[c - CHAR_0]) != 0)
+   { if (i > 0) c = (pcre_uint32)i; else escape = -i; }
  #else           /* EBCDIC coding */
  /* Not alphanumeric */
- else if (c < 'a' || (!MAX_255(c) || (ebcdic_chartab[c] & 0x0E) == 0)) {}
+ else if (c < CHAR_a || (!MAX_255(c) || (ebcdic_chartab[c] & 0x0E) == 0)) {}
- else if ((i = escapes[c - 0x48]) != 0)  c = i;
+ else if ((i = escapes[c - 0x48]) != 0)  { if (i > 0) c = (pcre_uint32)i; else escape = -i; }
  #endif
  /* Escapes that need further processing, or are illegal. */
-Line 795 
 else if ((i = escapes[c - 0x48]) != 0)
+Line 1030 
 else if ((i = escapes[c - 0x48]) != 0)
  else
    {
    const pcre_uchar *oldptr;
-   BOOL braced, negated;
+   BOOL braced, negated, overflow;
+   int s;
    switch (c)
      {
-Line 820 
 else
+Line 1056 
 else
          c = 0;
          for (i = 0; i < 4; ++i)
            {
-           register int cc = *(++ptr);
+           register pcre_uint32 cc = *(++ptr);
  #ifndef EBCDIC  /* ASCII/UTF-8 coding */
            if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
            c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
-Line 829 
 else
+Line 1065 
 else
            c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
  #endif
            }
+ #if defined COMPILE_PCRE8
+         if (c > (utf ? 0x10ffffU : 0xffU))
+ #elif defined COMPILE_PCRE16
+         if (c > (utf ? 0x10ffffU : 0xffffU))
+ #elif defined COMPILE_PCRE32
+         if (utf && c > 0x10ffffU)
+ #endif
+           {
+           *errorcodeptr = ERR76;
+           }
+         else if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
          }
        }
      else
-Line 855 
 else
+Line 1103 
 else
      (3) For Oniguruma compatibility we also support \g followed by a name or a
      number either in angle brackets or in single quotes. However, these are
      (possibly recursive) subroutine calls, _not_ backreferences. Just return
-     the -ESC_g code (cf \k). */
+     the ESC_g code (cf \k). */
      case CHAR_g:
      if (isclass) break;
      if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)
        {
-       c = -ESC_g;
+       escape = ESC_g;
        break;
        }
-Line 870 
 else
+Line 1118 
 else
      if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
        {
        const pcre_uchar *p;
-       for (p = ptr+2; *p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET; p++)
+       for (p = ptr+2; *p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET; p++)
          if (*p != CHAR_MINUS && !IS_DIGIT(*p)) break;
-       if (*p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET)
+       if (*p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET)
          {
-         c = -ESC_k;
+         escape = ESC_k;
          break;
          }
        braced = TRUE;
-Line 890 
 else
+Line 1138 
 else
      else negated = FALSE;
      /* The integer range is limited by the machine's int representation. */
-     c = 0;
+     s = 0;
+     overflow = FALSE;
      while (IS_DIGIT(ptr[1]))
        {
-       if (((unsigned int)c) > INT_MAX / 10) /* Integer overflow */
+       if (s > INT_MAX / 10 - 1) /* Integer overflow */
          {
-         c = -1;
+         overflow = TRUE;
          break;
          }
-       c = c * 10 + *(++ptr) - CHAR_0;
+       s = s * 10 + (int)(*(++ptr) - CHAR_0);
        }
-     if (((unsigned int)c) > INT_MAX) /* Integer overflow */
+     if (overflow) /* Integer overflow */
        {
        while (IS_DIGIT(ptr[1]))
          ptr++;
-Line 914 
 else
+Line 1163 
 else
        break;
        }
-     if (c == 0)
+     if (s == 0)
        {
        *errorcodeptr = ERR58;
        break;
-Line 922 
 else
+Line 1171 
 else
      if (negated)
        {
-       if (c > bracount)
+       if (s > bracount)
          {
          *errorcodeptr = ERR15;
          break;
          }
-       c = bracount - (c - 1);
+       s = bracount - (s - 1);
        }
-     c = -(ESC_REF + c);
+     escape = -s;
      break;
      /* The handling of escape sequences consisting of a string of digits
-     starting with one that is not zero is not straightforward. By experiment,
+     starting with one that is not zero is not straightforward. Perl has changed
-     the way Perl works seems to be as follows:
+     over the years. Nowadays \g{} for backreferences and \o{} for octal are
+     recommended to avoid the ambiguities in the old syntax.
      Outside a character class, the digits are read as a decimal number. If the
-     number is less than 10, or if there are that many previous extracting
+     number is less than 8 (used to be 10), or if there are that many previous
-     left brackets, then it is a back reference. Otherwise, up to three octal
+     extracting left brackets, then it is a back reference. Otherwise, up to
-     digits are read to form an escaped byte. Thus \123 is likely to be octal
+     three octal digits are read to form an escaped byte. Thus \123 is likely to
-(cf \0123, which is octal 012 followed by the literal 3). If the octal
+     be octal 123 (cf \0123, which is octal 012 followed by the literal 3). If
-     value is greater than 377, the least significant 8 bits are taken. Inside a
+     the octal value is greater than 377, the least significant 8 bits are
-     character class, \ followed by a digit is always an octal number. */
+     taken. \8 and \9 are treated as the literal characters 8 and 9.
+     Inside a character class, \ followed by a digit is always either a literal
+or 9 or an octal number. */
      case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5:
      case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
-Line 952 
 else
+Line 1205 
 else
        {
        oldptr = ptr;
        /* The integer range is limited by the machine's int representation. */
-       c -= CHAR_0;
+       s = (int)(c -CHAR_0);
+       overflow = FALSE;
        while (IS_DIGIT(ptr[1]))
          {
-         if (((unsigned int)c) > INT_MAX / 10) /* Integer overflow */
+         if (s > INT_MAX / 10 - 1) /* Integer overflow */
            {
-           c = -1;
+           overflow = TRUE;
            break;
            }
-         c = c * 10 + *(++ptr) - CHAR_0;
+         s = s * 10 + (int)(*(++ptr) - CHAR_0);
          }
-       if (((unsigned int)c) > INT_MAX) /* Integer overflow */
+       if (overflow) /* Integer overflow */
          {
          while (IS_DIGIT(ptr[1]))
            ptr++;
          *errorcodeptr = ERR61;
          break;
          }
-       if (c < 10 || c <= bracount)
+       if (s < 8 || s <= bracount)  /* Check for back reference */
          {
-         c = -(ESC_REF + c);
+         escape = -s;
          break;
          }
        ptr = oldptr;      /* Put the pointer back and fall through */
        }
-     /* Handle an octal number following \. If the first digit is 8 or 9, Perl
+     /* Handle a digit following \ when the number is not a back reference. If
-     generates a binary zero byte and treats the digit as a following literal.
+     the first digit is 8 or 9, Perl used to generate a binary zero byte and
-     Thus we have to pull back the pointer by one. */
+     then treat the digit as a following literal. At least by Perl 5.18 this
+     changed so as not to insert the binary zero. */
-     if ((c = *ptr) >= CHAR_8)
+     if ((c = *ptr) >= CHAR_8) break;
-       {
-       ptr--;
+     /* Fall through with a digit less than 8 */
-       c = 0;
-       break;
-       }
      /* \0 always starts an octal number, but we may drop through to here with a
      larger first octal digit. The original code used just to take the least
-Line 998 
 else
+Line 1250 
 else
      c -= CHAR_0;
      while(i++ < 2 && ptr[1] >= CHAR_0 && ptr[1] <= CHAR_7)
          c = c * 8 + *(++ptr) - CHAR_0;
  #ifdef COMPILE_PCRE8
      if (!utf && c > 0xff) *errorcodeptr = ERR51;
  #endif
+     break;
+     /* \o is a relatively new Perl feature, supporting a more general way of
+     specifying character codes in octal. The only supported form is \o{ddd}. */
+     case CHAR_o:
+     if (ptr[1] != CHAR_LEFT_CURLY_BRACKET) *errorcodeptr = ERR81; else
+     if (ptr[2] == CHAR_RIGHT_CURLY_BRACKET) *errorcodeptr = ERR86; else
+       {
+       ptr += 2;
+       c = 0;
+       overflow = FALSE;
+       while (*ptr >= CHAR_0 && *ptr <= CHAR_7)
+         {
+         register pcre_uint32 cc = *ptr++;
+         if (c == 0 && cc == CHAR_0) continue;     /* Leading zeroes */
+ #ifdef COMPILE_PCRE32
+         if (c >= 0x20000000l) { overflow = TRUE; break; }
+ #endif
+         c = (c << 3) + cc - CHAR_0 ;
+ #if defined COMPILE_PCRE8
+         if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }
+ #elif defined COMPILE_PCRE16
+         if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }
+ #elif defined COMPILE_PCRE32
+         if (utf && c > 0x10ffffU) { overflow = TRUE; break; }
+ #endif
+         }
+       if (overflow)
+         {
+         while (*ptr >= CHAR_0 && *ptr <= CHAR_7) ptr++;
+         *errorcodeptr = ERR34;
+         }
+       else if (*ptr == CHAR_RIGHT_CURLY_BRACKET)
+         {
+         if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
+         }
+       else *errorcodeptr = ERR80;
+       }
      break;
-     /* \x is complicated. \x{ddd} is a character number which can be greater
+     /* \x is complicated. In JavaScript, \x must be followed by two hexadecimal
-     than 0xff in utf or non-8bit mode, but only if the ddd are hex digits.
+     numbers. Otherwise it is a lowercase x letter. */
-     If not, { is treated as a data character. */
      case CHAR_x:
      if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)
        {
-       /* In JavaScript, \x must be followed by two hexadecimal numbers.
-       Otherwise it is a lowercase x letter. */
        if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0
          && MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0)
          {
          c = 0;
          for (i = 0; i < 2; ++i)
            {
-           register int cc = *(++ptr);
+           register pcre_uint32 cc = *(++ptr);
  #ifndef EBCDIC  /* ASCII/UTF-8 coding */
            if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
            c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
-Line 1028 
 else
+Line 1316 
 else
  #endif
            }
          }
-       break;
+       }    /* End JavaScript handling */
-       }
-     if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
+     /* Handle \x in Perl's style. \x{ddd} is a character number which can be
-       {
+     greater than 0xff in utf or non-8bit mode, but only if the ddd are hex
-       const pcre_uchar *pt = ptr + 2;
+     digits. If not, { used to be treated as a data character. However, Perl
+     seems to read hex digits up to the first non-such, and ignore the rest, so
+     that, for example \x{zz} matches a binary zero. This seems crazy, so PCRE
+     now gives an error. */
-       c = 0;
+     else
-       while (MAX_255(*pt) && (digitab[*pt] & ctype_xdigit) != 0)
+       {
+       if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
          {
-         register int cc = *pt++;
+         ptr += 2;
-         if (c == 0 && cc == CHAR_0) continue;     /* Leading zeroes */
+         if (*ptr == CHAR_RIGHT_CURLY_BRACKET)
+           {
+           *errorcodeptr = ERR86;
+           break;
+           }
+         c = 0;
+         overflow = FALSE;
+         while (MAX_255(*ptr) && (digitab[*ptr] & ctype_xdigit) != 0)
+           {
+           register pcre_uint32 cc = *ptr++;
+           if (c == 0 && cc == CHAR_0) continue;     /* Leading zeroes */
+ #ifdef COMPILE_PCRE32
+           if (c >= 0x10000000l) { overflow = TRUE; break; }
+ #endif
  #ifndef EBCDIC  /* ASCII/UTF-8 coding */
-         if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
+           if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
-         c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
+           c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
  #else           /* EBCDIC coding */
-         if (cc >= CHAR_a && cc <= CHAR_z) cc += 64;  /* Convert to upper case */
+           if (cc >= CHAR_a && cc <= CHAR_z) cc += 64;  /* Convert to upper case */
-         c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
+           c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
  #endif
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
-         if (c > (utf ? 0x10ffff : 0xff)) { c = -1; break; }
+           if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
+           if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }
-         if (c > (utf ? 0x10ffff : 0xffff)) { c = -1; break; }
+ #elif defined COMPILE_PCRE32
- #endif
+           if (utf && c > 0x10ffffU) { overflow = TRUE; break; }
  #endif
-         }
+           }
-       if (c < 0)
+         if (overflow)
-         {
+           {
-         while (MAX_255(*pt) && (digitab[*pt] & ctype_xdigit) != 0) pt++;
+           while (MAX_255(*ptr) && (digitab[*ptr] & ctype_xdigit) != 0) ptr++;
-         *errorcodeptr = ERR34;
+           *errorcodeptr = ERR34;
-         }
+           }
-       if (*pt == CHAR_RIGHT_CURLY_BRACKET)
+         else if (*ptr == CHAR_RIGHT_CURLY_BRACKET)
-         {
+           {
-         if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
+           if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
-         ptr = pt;
+           }
-         break;
-         }
-       /* If the sequence of hex digits does not end with '}', then we don't
+         /* If the sequence of hex digits does not end with '}', give an error.
-       recognize this construct; fall through to the normal \x handling. */
+         We used just to recognize this construct and fall through to the normal
-       }
+         \x handling, but nowadays Perl gives an error, which seems much more
+         sensible, so we do too. */
-     /* Read just a single-byte hex-defined char */
+         else *errorcodeptr = ERR79;
+         }   /* End of \x{} processing */
-     c = 0;
+       /* Read a single-byte hex-defined char (up to two hex digits after \x) */
-     while (i++ < 2 && MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0)
-       {
+       else
-       int cc;                                  /* Some compilers don't like */
+         {
-       cc = *(++ptr);                           /* ++ in initializers */
+         c = 0;
+         while (i++ < 2 && MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0)
+           {
+           pcre_uint32 cc;                          /* Some compilers don't like */
+           cc = *(++ptr);                           /* ++ in initializers */
  #ifndef EBCDIC  /* ASCII/UTF-8 coding */
-       if (cc >= CHAR_a) cc -= 32;              /* Convert to upper case */
+           if (cc >= CHAR_a) cc -= 32;              /* Convert to upper case */
-       c = c * 16 + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
+           c = c * 16 + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
  #else           /* EBCDIC coding */
-       if (cc <= CHAR_z) cc += 64;              /* Convert to upper case */
+           if (cc <= CHAR_z) cc += 64;              /* Convert to upper case */
-       c = c * 16 + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
+           c = c * 16 + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
  #endif
-       }
+           }
+         }     /* End of \xdd handling */
+       }       /* End of Perl-style \x handling */
      break;
      /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.
-Line 1099 
 else
+Line 1410 
 else
      case CHAR_c:
      c = *(++ptr);
-     if (c == 0)
+     if (c == CHAR_NULL)
        {
        *errorcodeptr = ERR2;
        break;
-Line 1139 
 else
+Line 1450 
 else
  newline". PCRE does not support \N{name}. However, it does support
  quantification such as \N{2,3}. */
- if (c == -ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET &&
+ if (escape == ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET &&
       !is_counted_repeat(ptr+2))
    *errorcodeptr = ERR37;
  /* If PCRE_UCP is set, we change the values for \d etc. */
- if ((options & PCRE_UCP) != 0 && c <= -ESC_D && c >= -ESC_w)
+ if ((options & PCRE_UCP) != 0 && escape >= ESC_D && escape <= ESC_w)
-   c -= (ESC_DU - ESC_D);
+   escape += (ESC_DU - ESC_D);
  /* Set the pointer to the final character before returning. */
  *ptrptr = ptr;
- return c;
+ *chptr = c;
+ return escape;
  }
-Line 1169 
 escape sequence.
+Line 1481 
 escape sequence.
  Argument:
    ptrptr         points to the pattern position pointer
    negptr         points to a boolean that is set TRUE for negation else FALSE
-   dptr           points to an int that is set to the detailed property value
+   ptypeptr       points to an unsigned int that is set to the type value
+   pdataptr       points to an unsigned int that is set to the detailed property value
    errorcodeptr   points to the error code variable
- Returns:         type value from ucp_type_table, or -1 for an invalid type
+ Returns:         TRUE if the type value was found, or FALSE for an invalid type
  */
- static int
+ static BOOL
- get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, int *dptr, int *errorcodeptr)
+ get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, unsigned int *ptypeptr,
+   unsigned int *pdataptr, int *errorcodeptr)
  {
- int c, i, bot, top;
+ pcre_uchar c;
+ int i, bot, top;
  const pcre_uchar *ptr = *ptrptr;
  pcre_uchar name[32];
  c = *(++ptr);
- if (c == 0) goto ERROR_RETURN;
+ if (c == CHAR_NULL) goto ERROR_RETURN;
  *negptr = FALSE;
-Line 1200 
 if (c == CHAR_LEFT_CURLY_BRACKET)
+Line 1515 
 if (c == CHAR_LEFT_CURLY_BRACKET)
    for (i = 0; i < (int)(sizeof(name) / sizeof(pcre_uchar)) - 1; i++)
      {
      c = *(++ptr);
-     if (c == 0) goto ERROR_RETURN;
+     if (c == CHAR_NULL) goto ERROR_RETURN;
      if (c == CHAR_RIGHT_CURLY_BRACKET) break;
      name[i] = c;
      }
-Line 1225 
 top = PRIV(utt_size);
+Line 1540 
 top = PRIV(utt_size);
  while (bot < top)
    {
+   int r;
    i = (bot + top) >> 1;
-   c = STRCMP_UC_C8(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);
+   r = STRCMP_UC_C8(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);
-   if (c == 0)
+   if (r == 0)
      {
-     *dptr = PRIV(utt)[i].value;
+     *ptypeptr = PRIV(utt)[i].type;
-     return PRIV(utt)[i].type;
+     *pdataptr = PRIV(utt)[i].value;
+     return TRUE;
      }
-   if (c > 0) bot = i + 1; else top = i;
+   if (r > 0) bot = i + 1; else top = i;
    }
  *errorcodeptr = ERR47;
  *ptrptr = ptr;
- return -1;
+ return FALSE;
  ERROR_RETURN:
  *errorcodeptr = ERR46;
  *ptrptr = ptr;
- return -1;
+ return FALSE;
  }
  #endif
  /*************************************************
  *         Read repeat counts                     *
  *************************************************/
-Line 1274 
 read_repeat_counts(const pcre_uchar *p,
+Line 1590 
 read_repeat_counts(const pcre_uchar *p,
  int min = 0;
  int max = -1;
- /* Read the minimum value and do a paranoid check: a negative value indicates
+ while (IS_DIGIT(*p))
- an integer overflow. */
- while (IS_DIGIT(*p)) min = min * 10 + *p++ - CHAR_0;
- if (min < 0 || min > 65535)
    {
-   *errorcodeptr = ERR5;
+   min = min * 10 + (int)(*p++ - CHAR_0);
-   return p;
+   if (min > 65535)
+     {
+     *errorcodeptr = ERR5;
+     return p;
+     }
    }
- /* Read the maximum value if there is one, and again do a paranoid on its size.
- Also, max must not be less than min. */
  if (*p == CHAR_RIGHT_CURLY_BRACKET) max = min; else
    {
    if (*(++p) != CHAR_RIGHT_CURLY_BRACKET)
      {
      max = 0;
-     while(IS_DIGIT(*p)) max = max * 10 + *p++ - CHAR_0;
+     while(IS_DIGIT(*p))
-     if (max < 0 || max > 65535)
        {
-       *errorcodeptr = ERR5;
+       max = max * 10 + (int)(*p++ - CHAR_0);
-       return p;
+       if (max > 65535)
+         {
+         *errorcodeptr = ERR5;
+         return p;
+         }
        }
      if (max < min)
        {
-Line 1306 
 if (*p == CHAR_RIGHT_CURLY_BRACKET) max
+Line 1622 
 if (*p == CHAR_RIGHT_CURLY_BRACKET) max
      }
    }
- /* Fill in the required variables, and pass back the pointer to the terminating
- '}'. */
  *minp = min;
  *maxp = max;
  return p;
-Line 1317 
 return p;
+Line 1630 
 return p;
  /*************************************************
- *  Subroutine for finding forward reference      *
- *************************************************/
- /* This recursive function is called only from find_parens() below. The
- top-level call starts at the beginning of the pattern. All other calls must
- start at a parenthesis. It scans along a pattern's text looking for capturing
- subpatterns, and counting them. If it finds a named pattern that matches the
- name it is given, it returns its number. Alternatively, if the name is NULL, it
- returns when it reaches a given numbered subpattern. Recursion is used to keep
- track of subpatterns that reset the capturing group numbers - the (?| feature.
- This function was originally called only from the second pass, in which we know
- that if (?< or (?' or (?P< is encountered, the name will be correctly
- terminated because that is checked in the first pass. There is now one call to
- this function in the first pass, to check for a recursive back reference by
- name (so that we can make the whole group atomic). In this case, we need check
- only up to the current position in the pattern, and that is still OK because
- and previous occurrences will have been checked. To make this work, the test
- for "end of pattern" is a check against cd->end_pattern in the main loop,
- instead of looking for a binary zero. This means that the special first-pass
- call can adjust cd->end_pattern temporarily. (Checks for binary zero while
- processing items within the loop are OK, because afterwards the main loop will
- terminate.)
- Arguments:
-   ptrptr       address of the current character pointer (updated)
-   cd           compile background data
-   name         name to seek, or NULL if seeking a numbered subpattern
-   lorn         name length, or subpattern number if name is NULL
-   xmode        TRUE if we are in /x mode
-   utf          TRUE if we are in UTF-8 / UTF-16 mode
-   count        pointer to the current capturing subpattern number (updated)
- Returns:       the number of the named subpattern, or -1 if not found
- */
- static int
- find_parens_sub(pcre_uchar **ptrptr, compile_data *cd, const pcre_uchar *name, int lorn,
-   BOOL xmode, BOOL utf, int *count)
- {
- pcre_uchar *ptr = *ptrptr;
- int start_count = *count;
- int hwm_count = start_count;
- BOOL dup_parens = FALSE;
- /* If the first character is a parenthesis, check on the type of group we are
- dealing with. The very first call may not start with a parenthesis. */
- if (ptr[0] == CHAR_LEFT_PARENTHESIS)
-   {
-   /* Handle specials such as (*SKIP) or (*UTF8) etc. */
-   if (ptr[1] == CHAR_ASTERISK) ptr += 2;
-   /* Handle a normal, unnamed capturing parenthesis. */
-   else if (ptr[1] != CHAR_QUESTION_MARK)
-     {
-     *count += 1;
-     if (name == NULL && *count == lorn) return *count;
-     ptr++;
-     }
-   /* All cases now have (? at the start. Remember when we are in a group
-   where the parenthesis numbers are duplicated. */
-   else if (ptr[2] == CHAR_VERTICAL_LINE)
-     {
-     ptr += 3;
-     dup_parens = TRUE;
-     }
-   /* Handle comments; all characters are allowed until a ket is reached. */
-   else if (ptr[2] == CHAR_NUMBER_SIGN)
-     {
-     for (ptr += 3; *ptr != 0; ptr++) if (*ptr == CHAR_RIGHT_PARENTHESIS) break;
-     goto FAIL_EXIT;
-     }
-   /* Handle a condition. If it is an assertion, just carry on so that it
-   is processed as normal. If not, skip to the closing parenthesis of the
-   condition (there can't be any nested parens). */
-   else if (ptr[2] == CHAR_LEFT_PARENTHESIS)
-     {
-     ptr += 2;
-     if (ptr[1] != CHAR_QUESTION_MARK)
-       {
-       while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
-       if (*ptr != 0) ptr++;
-       }
-     }
-   /* Start with (? but not a condition. */
-   else
-     {
-     ptr += 2;
-     if (*ptr == CHAR_P) ptr++;                      /* Allow optional P */
-     /* We have to disambiguate (?<! and (?<= from (?<name> for named groups */
-     if ((*ptr == CHAR_LESS_THAN_SIGN && ptr[1] != CHAR_EXCLAMATION_MARK &&
-         ptr[1] != CHAR_EQUALS_SIGN) || *ptr == CHAR_APOSTROPHE)
-       {
-       int term;
-       const pcre_uchar *thisname;
-       *count += 1;
-       if (name == NULL && *count == lorn) return *count;
-       term = *ptr++;
-       if (term == CHAR_LESS_THAN_SIGN) term = CHAR_GREATER_THAN_SIGN;
-       thisname = ptr;
-       while (*ptr != term) ptr++;
-       if (name != NULL && lorn == ptr - thisname &&
-           STRNCMP_UC_UC(name, thisname, lorn) == 0)
-         return *count;
-       term++;
-       }
-     }
-   }
- /* Past any initial parenthesis handling, scan for parentheses or vertical
- bars. Stop if we get to cd->end_pattern. Note that this is important for the
- first-pass call when this value is temporarily adjusted to stop at the current
- position. So DO NOT change this to a test for binary zero. */
- for (; ptr < cd->end_pattern; ptr++)
-   {
-   /* Skip over backslashed characters and also entire \Q...\E */
-   if (*ptr == CHAR_BACKSLASH)
-     {
-     if (*(++ptr) == 0) goto FAIL_EXIT;
-     if (*ptr == CHAR_Q) for (;;)
-       {
-       while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};
-       if (*ptr == 0) goto FAIL_EXIT;
-       if (*(++ptr) == CHAR_E) break;
-       }
-     continue;
-     }
-   /* Skip over character classes; this logic must be similar to the way they
-   are handled for real. If the first character is '^', skip it. Also, if the
-   first few characters (either before or after ^) are \Q\E or \E we skip them
-   too. This makes for compatibility with Perl. Note the use of STR macros to
-   encode "Q\\E" so that it works in UTF-8 on EBCDIC platforms. */
-   if (*ptr == CHAR_LEFT_SQUARE_BRACKET)
-     {
-     BOOL negate_class = FALSE;
-     for (;;)
-       {
-       if (ptr[1] == CHAR_BACKSLASH)
-         {
-         if (ptr[2] == CHAR_E)
-           ptr+= 2;
-         else if (STRNCMP_UC_C8(ptr + 2,
-                  STR_Q STR_BACKSLASH STR_E, 3) == 0)
-           ptr += 4;
-         else
-           break;
-         }
-       else if (!negate_class && ptr[1] == CHAR_CIRCUMFLEX_ACCENT)
-         {
-         negate_class = TRUE;
-         ptr++;
-         }
-       else break;
-       }
-     /* If the next character is ']', it is a data character that must be
-     skipped, except in JavaScript compatibility mode. */
-     if (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET &&
-         (cd->external_options & PCRE_JAVASCRIPT_COMPAT) == 0)
-       ptr++;
-     while (*(++ptr) != CHAR_RIGHT_SQUARE_BRACKET)
-       {
-       if (*ptr == 0) return -1;
-       if (*ptr == CHAR_BACKSLASH)
-         {
-         if (*(++ptr) == 0) goto FAIL_EXIT;
-         if (*ptr == CHAR_Q) for (;;)
-           {
-           while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};
-           if (*ptr == 0) goto FAIL_EXIT;
-           if (*(++ptr) == CHAR_E) break;
-           }
-         continue;
-         }
-       }
-     continue;
-     }
-   /* Skip comments in /x mode */
-   if (xmode && *ptr == CHAR_NUMBER_SIGN)
-     {
-     ptr++;
-     while (*ptr != 0)
-       {
-       if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }
-       ptr++;
- #ifdef SUPPORT_UTF
-       if (utf) FORWARDCHAR(ptr);
- #endif
-       }
-     if (*ptr == 0) goto FAIL_EXIT;
-     continue;
-     }
-   /* Check for the special metacharacters */
-   if (*ptr == CHAR_LEFT_PARENTHESIS)
-     {
-     int rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf, count);
-     if (rc > 0) return rc;
-     if (*ptr == 0) goto FAIL_EXIT;
-     }
-   else if (*ptr == CHAR_RIGHT_PARENTHESIS)
-     {
-     if (dup_parens && *count < hwm_count) *count = hwm_count;
-     goto FAIL_EXIT;
-     }
-   else if (*ptr == CHAR_VERTICAL_LINE && dup_parens)
-     {
-     if (*count > hwm_count) hwm_count = *count;
-     *count = start_count;
-     }
-   }
- FAIL_EXIT:
- *ptrptr = ptr;
- return -1;
- }
- /*************************************************
- *       Find forward referenced subpattern       *
- *************************************************/
- /* This function scans along a pattern's text looking for capturing
- subpatterns, and counting them. If it finds a named pattern that matches the
- name it is given, it returns its number. Alternatively, if the name is NULL, it
- returns when it reaches a given numbered subpattern. This is used for forward
- references to subpatterns. We used to be able to start this scan from the
- current compiling point, using the current count value from cd->bracount, and
- do it all in a single loop, but the addition of the possibility of duplicate
- subpattern numbers means that we have to scan from the very start, in order to
- take account of such duplicates, and to use a recursive function to keep track
- of the different types of group.
- Arguments:
-   cd           compile background data
-   name         name to seek, or NULL if seeking a numbered subpattern
-   lorn         name length, or subpattern number if name is NULL
-   xmode        TRUE if we are in /x mode
-   utf          TRUE if we are in UTF-8 / UTF-16 mode
- Returns:       the number of the found subpattern, or -1 if not found
- */
- static int
- find_parens(compile_data *cd, const pcre_uchar *name, int lorn, BOOL xmode,
-   BOOL utf)
- {
- pcre_uchar *ptr = (pcre_uchar *)cd->start_pattern;
- int count = 0;
- int rc;
- /* If the pattern does not start with an opening parenthesis, the first call
- to find_parens_sub() will scan right to the end (if necessary). However, if it
- does start with a parenthesis, find_parens_sub() will return when it hits the
- matching closing parens. That is why we have to have a loop. */
- for (;;)
-   {
-   rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf, &count);
-   if (rc > 0 || *ptr++ == 0) break;
-   }
- return rc;
- }
- /*************************************************
  *      Find first significant op code            *
  *************************************************/
-Line 1650 
 for (;;)
+Line 1668 
 for (;;)
      case OP_CALLOUT:
      case OP_CREF:
-     case OP_NCREF:
+     case OP_DNCREF:
      case OP_RREF:
-     case OP_NRREF:
+     case OP_DNRREF:
      case OP_DEF:
      code += PRIV(OP_lengths)[*code];
      break;
-Line 1666 
 for (;;)
+Line 1684 
 for (;;)
  /*************************************************
  *        Find the fixed length of a branch       *
  *************************************************/
-Line 1684 
 and doing the check at the end; a flag s
+Line 1701 
 and doing the check at the end; a flag s
  Arguments:
    code     points to the start of the pattern (the bracket)
-   utf      TRUE in UTF-8 / UTF-16 mode
+   utf      TRUE in UTF-8 / UTF-16 / UTF-32 mode
    atend    TRUE if called when the pattern is complete
    cd       the "compile data" structure
-Line 1710 
 for (;;)
+Line 1727 
 for (;;)
    {
    int d;
    pcre_uchar *ce, *cs;
-   register int op = *cc;
+   register pcre_uchar op = *cc;
    switch (op)
      {
-Line 1790 
 for (;;)
+Line 1807 
 for (;;)
      case OP_COMMIT:
      case OP_CREF:
      case OP_DEF:
+     case OP_DNCREF:
+     case OP_DNRREF:
      case OP_DOLL:
      case OP_DOLLM:
      case OP_EOD:
      case OP_EODN:
      case OP_FAIL:
-     case OP_NCREF:
-     case OP_NRREF:
      case OP_NOT_WORD_BOUNDARY:
      case OP_PRUNE:
      case OP_REVERSE:
-Line 1830 
 for (;;)
+Line 1847 
 for (;;)
      case OP_EXACTI:
      case OP_NOTEXACT:
      case OP_NOTEXACTI:
-     branchlength += GET2(cc,1);
+     branchlength += (int)GET2(cc,1);
      cc += 2 + IMM2_SIZE;
  #ifdef SUPPORT_UTF
      if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
-Line 1839 
 for (;;)
+Line 1856 
 for (;;)
      case OP_TYPEEXACT:
      branchlength += GET2(cc,1);
-     if (cc[1 + IMM2_SIZE] == OP_PROP || cc[1 + IMM2_SIZE] == OP_NOTPROP) cc += 2;
+     if (cc[1 + IMM2_SIZE] == OP_PROP || cc[1 + IMM2_SIZE] == OP_NOTPROP)
+       cc += 2;
      cc += 1 + IMM2_SIZE + 1;
      break;
-Line 1874 
 for (;;)
+Line 1892 
 for (;;)
      /* Check a class for variable quantification */
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+     case OP_CLASS:
+     case OP_NCLASS:
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
      case OP_XCLASS:
-     cc += GET(cc, 1) - PRIV(OP_lengths)[OP_CLASS];
+     /* The original code caused an unsigned overflow in 64 bit systems,
-     /* Fall through */
+     so now we use a conditional statement. */
- #endif
+     if (op == OP_XCLASS)
+       cc += GET(cc, 1);
-     case OP_CLASS:
+     else
-     case OP_NCLASS:
+       cc += PRIV(OP_lengths)[OP_CLASS];
+ #else
      cc += PRIV(OP_lengths)[OP_CLASS];
+ #endif
      switch (*cc)
        {
-       case OP_CRPLUS:
-       case OP_CRMINPLUS:
        case OP_CRSTAR:
        case OP_CRMINSTAR:
+       case OP_CRPLUS:
+       case OP_CRMINPLUS:
        case OP_CRQUERY:
        case OP_CRMINQUERY:
+       case OP_CRPOSSTAR:
+       case OP_CRPOSPLUS:
+       case OP_CRPOSQUERY:
        return -1;
        case OP_CRRANGE:
        case OP_CRMINRANGE:
+       case OP_CRPOSRANGE:
        if (GET2(cc,1) != GET2(cc,1+IMM2_SIZE)) return -1;
-       branchlength += GET2(cc,1);
+       branchlength += (int)GET2(cc,1);
        cc += 1 + 2 * IMM2_SIZE;
        break;
-Line 1964 
 for (;;)
+Line 1990 
 for (;;)
      case OP_QUERYI:
      case OP_REF:
      case OP_REFI:
+     case OP_DNREF:
+     case OP_DNREFI:
      case OP_SBRA:
      case OP_SBRAPOS:
      case OP_SCBRA:
-Line 2000 
 for (;;)
+Line 2028 
 for (;;)
  /*************************************************
  *    Scan compiled regex for specific bracket    *
  *************************************************/
-Line 2013 
 length.
+Line 2040 
 length.
  Arguments:
    code        points to start of expression
-   utf         TRUE in UTF-8 / UTF-16 mode
+   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
    number      the required bracket number or negative to find a lookbehind
  Returns:      pointer to the opcode for the bracket, or NULL if not found
-Line 2024 
 PRIV(find_bracket)(const pcre_uchar *cod
+Line 2051 
 PRIV(find_bracket)(const pcre_uchar *cod
  {
  for (;;)
    {
-   register int c = *code;
+   register pcre_uchar c = *code;
    if (c == OP_END) return NULL;
-Line 2047 
 for (;;)
+Line 2074 
 for (;;)
    else if (c == OP_CBRA || c == OP_SCBRA ||
             c == OP_CBRAPOS || c == OP_SCBRAPOS)
      {
-     int n = GET2(code, 1+LINK_SIZE);
+     int n = (int)GET2(code, 1+LINK_SIZE);
      if (n == number) return (pcre_uchar *)code;
      code += PRIV(OP_lengths)[c];
      }
-Line 2077 
 for (;;)
+Line 2104 
 for (;;)
        case OP_TYPEMINUPTO:
        case OP_TYPEEXACT:
        case OP_TYPEPOSUPTO:
-       if (code[1 + IMM2_SIZE] == OP_PROP
+       if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
-         || code[1 + IMM2_SIZE] == OP_NOTPROP) code += 2;
+         code += 2;
        break;
        case OP_MARK:
        case OP_PRUNE_ARG:
        case OP_SKIP_ARG:
-       code += code[1];
-       break;
        case OP_THEN_ARG:
        code += code[1];
        break;
-Line 2100 
 for (;;)
+Line 2124 
 for (;;)
    a multi-byte character. The length in the table is a minimum, so we have to
    arrange to skip the extra bytes. */
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (utf) switch(c)
        {
        case OP_CHAR:
        case OP_CHARI:
+       case OP_NOT:
+       case OP_NOTI:
        case OP_EXACT:
        case OP_EXACTI:
+       case OP_NOTEXACT:
+       case OP_NOTEXACTI:
        case OP_UPTO:
        case OP_UPTOI:
+       case OP_NOTUPTO:
+       case OP_NOTUPTOI:
        case OP_MINUPTO:
        case OP_MINUPTOI:
+       case OP_NOTMINUPTO:
+       case OP_NOTMINUPTOI:
        case OP_POSUPTO:
        case OP_POSUPTOI:
+       case OP_NOTPOSUPTO:
+       case OP_NOTPOSUPTOI:
        case OP_STAR:
        case OP_STARI:
+       case OP_NOTSTAR:
+       case OP_NOTSTARI:
        case OP_MINSTAR:
        case OP_MINSTARI:
+       case OP_NOTMINSTAR:
+       case OP_NOTMINSTARI:
        case OP_POSSTAR:
        case OP_POSSTARI:
+       case OP_NOTPOSSTAR:
+       case OP_NOTPOSSTARI:
        case OP_PLUS:
        case OP_PLUSI:
+       case OP_NOTPLUS:
+       case OP_NOTPLUSI:
        case OP_MINPLUS:
        case OP_MINPLUSI:
+       case OP_NOTMINPLUS:
+       case OP_NOTMINPLUSI:
        case OP_POSPLUS:
        case OP_POSPLUSI:
+       case OP_NOTPOSPLUS:
+       case OP_NOTPOSPLUSI:
        case OP_QUERY:
        case OP_QUERYI:
+       case OP_NOTQUERY:
+       case OP_NOTQUERYI:
        case OP_MINQUERY:
        case OP_MINQUERYI:
+       case OP_NOTMINQUERY:
+       case OP_NOTMINQUERYI:
        case OP_POSQUERY:
        case OP_POSQUERYI:
+       case OP_NOTPOSQUERY:
+       case OP_NOTPOSQUERYI:
        if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
        break;
        }
-Line 2152 
 instance of OP_RECURSE.
+Line 2204 
 instance of OP_RECURSE.
  Arguments:
    code        points to start of expression
-   utf         TRUE in UTF-8 / UTF-16 mode
+   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
  Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
  */
-Line 2162 
 find_recurse(const pcre_uchar *code, BOO
+Line 2214 
 find_recurse(const pcre_uchar *code, BOO
  {
  for (;;)
    {
-   register int c = *code;
+   register pcre_uchar c = *code;
    if (c == OP_END) return NULL;
    if (c == OP_RECURSE) return code;
-Line 2197 
 for (;;)
+Line 2249 
 for (;;)
        case OP_TYPEUPTO:
        case OP_TYPEMINUPTO:
        case OP_TYPEEXACT:
-       if (code[1 + IMM2_SIZE] == OP_PROP
+       if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
-         || code[1 + IMM2_SIZE] == OP_NOTPROP) code += 2;
+         code += 2;
        break;
        case OP_MARK:
        case OP_PRUNE_ARG:
        case OP_SKIP_ARG:
-       code += code[1];
-       break;
        case OP_THEN_ARG:
        code += code[1];
        break;
-Line 2220 
 for (;;)
+Line 2269 
 for (;;)
      by a multi-byte character. The length in the table is a minimum, so we have
      to arrange to skip the extra bytes. */
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (utf) switch(c)
        {
        case OP_CHAR:
        case OP_CHARI:
+       case OP_NOT:
+       case OP_NOTI:
        case OP_EXACT:
        case OP_EXACTI:
+       case OP_NOTEXACT:
+       case OP_NOTEXACTI:
        case OP_UPTO:
        case OP_UPTOI:
+       case OP_NOTUPTO:
+       case OP_NOTUPTOI:
        case OP_MINUPTO:
        case OP_MINUPTOI:
+       case OP_NOTMINUPTO:
+       case OP_NOTMINUPTOI:
        case OP_POSUPTO:
        case OP_POSUPTOI:
+       case OP_NOTPOSUPTO:
+       case OP_NOTPOSUPTOI:
        case OP_STAR:
        case OP_STARI:
+       case OP_NOTSTAR:
+       case OP_NOTSTARI:
        case OP_MINSTAR:
        case OP_MINSTARI:
+       case OP_NOTMINSTAR:
+       case OP_NOTMINSTARI:
        case OP_POSSTAR:
        case OP_POSSTARI:
+       case OP_NOTPOSSTAR:
+       case OP_NOTPOSSTARI:
        case OP_PLUS:
        case OP_PLUSI:
+       case OP_NOTPLUS:
+       case OP_NOTPLUSI:
        case OP_MINPLUS:
        case OP_MINPLUSI:
+       case OP_NOTMINPLUS:
+       case OP_NOTMINPLUSI:
        case OP_POSPLUS:
        case OP_POSPLUSI:
+       case OP_NOTPOSPLUS:
+       case OP_NOTPOSPLUSI:
        case OP_QUERY:
        case OP_QUERYI:
+       case OP_NOTQUERY:
+       case OP_NOTQUERYI:
        case OP_MINQUERY:
        case OP_MINQUERYI:
+       case OP_NOTMINQUERY:
+       case OP_NOTMINQUERYI:
        case OP_POSQUERY:
        case OP_POSQUERYI:
+       case OP_NOTPOSQUERY:
+       case OP_NOTPOSQUERYI:
        if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
        break;
        }
-Line 2278 
 bracket whose current branch will alread
+Line 2355 
 bracket whose current branch will alread
  Arguments:
    code        points to start of search
    endcode     points to where to stop
-   utf         TRUE if in UTF-8 / UTF-16 mode
+   utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
    cd          contains pointers to tables etc.
+   recurses    chain of recurse_check to catch mutual recursion
  Returns:      TRUE if what is matched could be empty
  */
+ typedef struct recurse_check {
+   struct recurse_check *prev;
+   const pcre_uchar *group;
+ } recurse_check;
  static BOOL
  could_be_empty_branch(const pcre_uchar *code, const pcre_uchar *endcode,
-   BOOL utf, compile_data *cd)
+   BOOL utf, compile_data *cd, recurse_check *recurses)
  {
- register int c;
+ register pcre_uchar c;
+ recurse_check this_recurse;
  for (code = first_significant_code(code + PRIV(OP_lengths)[*code], TRUE);
       code < endcode;
       code = first_significant_code(code + PRIV(OP_lengths)[c], TRUE))
-Line 2316 
 for (code = first_significant_code(code
+Line 2401 
 for (code = first_significant_code(code
    if (c == OP_RECURSE)
      {
-     const pcre_uchar *scode;
+     const pcre_uchar *scode = cd->start_code + GET(code, 1);
+     const pcre_uchar *endgroup = scode;
      BOOL empty_branch;
-     /* Test for forward reference */
+     /* Test for forward reference or uncompleted reference. This is disabled
+     when called to scan a completed pattern by setting cd->start_workspace to
+     NULL. */
+     if (cd->start_workspace != NULL)
+       {
+       const pcre_uchar *tcode;
+       for (tcode = cd->start_workspace; tcode < cd->hwm; tcode += LINK_SIZE)
+         if ((int)GET(tcode, 0) == (int)(code + 1 - cd->start_code)) return TRUE;
+       if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
+       }
+     /* If the reference is to a completed group, we need to detect whether this
+     is a recursive call, as otherwise there will be an infinite loop. If it is
+     a recursion, just skip over it. Simple recursions are easily detected. For
+     mutual recursions we keep a chain on the stack. */
-     for (scode = cd->start_workspace; scode < cd->hwm; scode += LINK_SIZE)
+     do endgroup += GET(endgroup, 1); while (*endgroup == OP_ALT);
-       if (GET(scode, 0) == code + 1 - cd->start_code) return TRUE;
+     if (code >= scode && code <= endgroup) continue;  /* Simple recursion */
+     else
+       {
+       recurse_check *r = recurses;
+       for (r = recurses; r != NULL; r = r->prev)
+         if (r->group == scode) break;
+       if (r != NULL) continue;   /* Mutual recursion */
+       }
-     /* Not a forward reference, test for completed backward reference */
+     /* Completed reference; scan the referenced group, remembering it on the
+     stack chain to detect mutual recursions. */
      empty_branch = FALSE;
-     scode = cd->start_code + GET(code, 1);
+     this_recurse.prev = recurses;
-     if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
+     this_recurse.group = scode;
-     /* Completed backwards reference */
      do
        {
-       if (could_be_empty_branch(scode, endcode, utf, cd))
+       if (could_be_empty_branch(scode, endcode, utf, cd, &this_recurse))
          {
          empty_branch = TRUE;
          break;
-Line 2390 
 for (code = first_significant_code(code
+Line 2497 
 for (code = first_significant_code(code
        empty_branch = FALSE;
        do
          {
-         if (!empty_branch && could_be_empty_branch(code, endcode, utf, cd))
+         if (!empty_branch && could_be_empty_branch(code, endcode, utf, cd,
-           empty_branch = TRUE;
+           recurses)) empty_branch = TRUE;
          code += GET(code, 1);
          }
        while (*code == OP_ALT);
-Line 2432 
 for (code = first_significant_code(code
+Line 2539 
 for (code = first_significant_code(code
        case OP_CRMINSTAR:
        case OP_CRQUERY:
        case OP_CRMINQUERY:
+       case OP_CRPOSSTAR:
+       case OP_CRPOSQUERY:
        break;
        default:                   /* Non-repeat => class must match */
        case OP_CRPLUS:            /* These repeats aren't empty */
        case OP_CRMINPLUS:
+       case OP_CRPOSPLUS:
        return FALSE;
        case OP_CRRANGE:
        case OP_CRMINRANGE:
+       case OP_CRPOSRANGE:
        if (GET2(ccode, 1) > 0) return FALSE;  /* Minimum > 0 */
        break;
        }
-Line 2448 
 for (code = first_significant_code(code
+Line 2559 
 for (code = first_significant_code(code
      /* Opcodes that must match a character */
+     case OP_ANY:
+     case OP_ALLANY:
+     case OP_ANYBYTE:
      case OP_PROP:
      case OP_NOTPROP:
+     case OP_ANYNL:
+     case OP_NOT_HSPACE:
+     case OP_HSPACE:
+     case OP_NOT_VSPACE:
+     case OP_VSPACE:
      case OP_EXTUNI:
      case OP_NOT_DIGIT:
      case OP_DIGIT:
      case OP_NOT_WHITESPACE:
      case OP_WHITESPACE:
      case OP_NOT_WORDCHAR:
      case OP_WORDCHAR:
-     case OP_ANY:
-     case OP_ALLANY:
-     case OP_ANYBYTE:
      case OP_CHAR:
      case OP_CHARI:
      case OP_NOT:
      case OP_NOTI:
      case OP_PLUS:
+     case OP_PLUSI:
      case OP_MINPLUS:
-     case OP_POSPLUS:
+     case OP_MINPLUSI:
-     case OP_EXACT:
      case OP_NOTPLUS:
+     case OP_NOTPLUSI:
      case OP_NOTMINPLUS:
+     case OP_NOTMINPLUSI:
+     case OP_POSPLUS:
+     case OP_POSPLUSI:
      case OP_NOTPOSPLUS:
+     case OP_NOTPOSPLUSI:
+     case OP_EXACT:
+     case OP_EXACTI:
      case OP_NOTEXACT:
+     case OP_NOTEXACTI:
      case OP_TYPEPLUS:
      case OP_TYPEMINPLUS:
      case OP_TYPEPOSPLUS:
      case OP_TYPEEXACT:
      return FALSE;
      /* These are going to continue, as they may be empty, but we have to
-Line 2495 
 for (code = first_significant_code(code
+Line 2629 
 for (code = first_significant_code(code
      case OP_TYPEUPTO:
      case OP_TYPEMINUPTO:
      case OP_TYPEPOSUPTO:
-     if (code[1 + IMM2_SIZE] == OP_PROP
+     if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
-       || code[1 + IMM2_SIZE] == OP_NOTPROP) code += 2;
+       code += 2;
      break;
      /* End of branch */
-Line 2509 
 for (code = first_significant_code(code
+Line 2643 
 for (code = first_significant_code(code
      return TRUE;
      /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,
-     MINUPTO, and POSUPTO may be followed by a multibyte character */
+     MINUPTO, and POSUPTO and their caseless and negative versions may be
+     followed by a multibyte character. */
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      case OP_STAR:
      case OP_STARI:
+     case OP_NOTSTAR:
+     case OP_NOTSTARI:
      case OP_MINSTAR:
      case OP_MINSTARI:
+     case OP_NOTMINSTAR:
+     case OP_NOTMINSTARI:
      case OP_POSSTAR:
      case OP_POSSTARI:
+     case OP_NOTPOSSTAR:
+     case OP_NOTPOSSTARI:
      case OP_QUERY:
      case OP_QUERYI:
+     case OP_NOTQUERY:
+     case OP_NOTQUERYI:
      case OP_MINQUERY:
      case OP_MINQUERYI:
+     case OP_NOTMINQUERY:
+     case OP_NOTMINQUERYI:
      case OP_POSQUERY:
      case OP_POSQUERYI:
+     case OP_NOTPOSQUERY:
+     case OP_NOTPOSQUERYI:
      if (utf && HAS_EXTRALEN(code[1])) code += GET_EXTRALEN(code[1]);
      break;
      case OP_UPTO:
      case OP_UPTOI:
+     case OP_NOTUPTO:
+     case OP_NOTUPTOI:
      case OP_MINUPTO:
      case OP_MINUPTOI:
+     case OP_NOTMINUPTO:
+     case OP_NOTMINUPTOI:
      case OP_POSUPTO:
      case OP_POSUPTOI:
+     case OP_NOTPOSUPTO:
+     case OP_NOTPOSUPTOI:
      if (utf && HAS_EXTRALEN(code[1 + IMM2_SIZE])) code += GET_EXTRALEN(code[1 + IMM2_SIZE]);
      break;
  #endif
-Line 2543 
 for (code = first_significant_code(code
+Line 2705 
 for (code = first_significant_code(code
      case OP_MARK:
      case OP_PRUNE_ARG:
      case OP_SKIP_ARG:
-     code += code[1];
-     break;
      case OP_THEN_ARG:
      code += code[1];
      break;
-Line 2577 
 Arguments:
+Line 2736 
 Arguments:
    code        points to start of the recursion
    endcode     points to where to stop (current RECURSE item)
    bcptr       points to the chain of current (unclosed) branch starts
-   utf         TRUE if in UTF-8 / UTF-16 mode
+   utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
    cd          pointers to tables etc
  Returns:      TRUE if what is matched could be empty
-Line 2589 
 could_be_empty(const pcre_uchar *code, c
+Line 2748 
 could_be_empty(const pcre_uchar *code, c
  {
  while (bcptr != NULL && bcptr->current_branch >= code)
    {
-   if (!could_be_empty_branch(bcptr->current_branch, endcode, utf, cd))
+   if (!could_be_empty_branch(bcptr->current_branch, endcode, utf, cd, NULL))
      return FALSE;
    bcptr = bcptr->outer;
    }
-Line 2599 
 return TRUE;
+Line 2758 
 return TRUE;
  /*************************************************
- *           Check for POSIX class syntax         *
+ *        Base opcode of repeated opcodes         *
  *************************************************/
- /* This function is called when the sequence "[:" or "[." or "[=" is
+ /* Returns the base opcode for repeated single character type opcodes. If the
- encountered in a character class. It checks whether this is followed by a
+ opcode is not a repeated character type, it returns with the original value.
- sequence of characters terminated by a matching ":]" or ".]" or "=]". If we
- reach an unescaped ']' without the special preceding character, return FALSE.
- Originally, this function only recognized a sequence of letters between the
+ Arguments:  c opcode
- terminators, but it seems that Perl recognizes any sequence of characters,
+ Returns:    base opcode for the type
- though of course unknown POSIX names are subsequently rejected. Perl gives an
+ */
- "Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE
- didn't consider this to be a POSIX class. Likewise for [:1234:].
- The problem in trying to be exactly like Perl is in the handling of escapes. We
+ static pcre_uchar
- have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
+ get_repeat_base(pcre_uchar c)
- class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
+ {
- below handles the special case of \], but does not try to do any other escape
+ return (c > OP_TYPEPOSUPTO)? c :
- processing. This makes it different from Perl for cases such as [:l\ower:]
+        (c >= OP_TYPESTAR)?   OP_TYPESTAR :
- where Perl recognizes it as the POSIX class "lower" but PCRE does not recognize
+        (c >= OP_NOTSTARI)?   OP_NOTSTARI :
- "l\ower". This is a lesser evil that not diagnosing bad classes when Perl does,
+        (c >= OP_NOTSTAR)?    OP_NOTSTAR :
- I think.
+        (c >= OP_STARI)?      OP_STARI :
+                              OP_STAR;
+ }
- A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not.
- It seems that the appearance of a nested POSIX class supersedes an apparent
- external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or
- a digit.
- In Perl, unescaped square brackets may also appear as part of class names. For
- example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for
+ #ifdef SUPPORT_UCP
- [:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not
+ /*************************************************
- seem right at all. PCRE does not allow closing square brackets in POSIX class
+ *        Check a character and a property        *
- names.
+ *************************************************/
+ /* This function is called by check_auto_possessive() when a property item
+ is adjacent to a fixed character.
  Arguments:
-   ptr      pointer to the initial [
+   c            the character
-   endptr   where to return the end pointer
+   ptype        the property type
+   pdata        the data for the type
+   negated      TRUE if it's a negated property (\P or \p{^)
- Returns:   TRUE or FALSE
+ Returns:       TRUE if auto-possessifying is OK
  */
  static BOOL
- check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr)
+ check_char_prop(pcre_uint32 c, unsigned int ptype, unsigned int pdata,
+   BOOL negated)
  {
- int terminator;          /* Don't combine these lines; the Solaris cc */
+ const pcre_uint32 *p;
- terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
+ const ucd_record *prop = GET_UCD(c);
- for (++ptr; *ptr != 0; ptr++)
+ switch(ptype)
    {
-   if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
+   case PT_LAMP:
-     ptr++;
+   return (prop->chartype == ucp_Lu ||
-   else if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
+           prop->chartype == ucp_Ll ||
-   else
+           prop->chartype == ucp_Lt) == negated;
-     {
-     if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
-       {
-       *endptr = ptr;
-       return TRUE;
-       }
-     if (*ptr == CHAR_LEFT_SQUARE_BRACKET &&
-          (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
-           ptr[1] == CHAR_EQUALS_SIGN) &&
-         check_posix_syntax(ptr, endptr))
-       return FALSE;
-     }
-   }
- return FALSE;
- }
+   case PT_GC:
+   return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;
+   case PT_PC:
+   return (pdata == prop->chartype) == negated;
+   case PT_SC:
+   return (pdata == prop->script) == negated;
- /*************************************************
+   /* These are specials */
- *          Check POSIX class name                *
- *************************************************/
- /* This function is called to check the name given in a POSIX-style class entry
+   case PT_ALNUM:
- such as [:alnum:].
+   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+           PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;
- Arguments:
+   /* Perl space used to exclude VT, but from Perl 5.18 it is included, which
-   ptr        points to the first letter
+   means that Perl space and POSIX space are now identical. PCRE was changed
-   len        the length of the name
+   at release 8.34. */
- Returns:     a value representing the name, or -1 if unknown
+   case PT_SPACE:    /* Perl space */
- */
+   case PT_PXSPACE:  /* POSIX space */
+   switch(c)
+     {
+     HSPACE_CASES:
+     VSPACE_CASES:
+     return negated;
- static int
+     default:
- check_posix_name(const pcre_uchar *ptr, int len)
+     return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == negated;
- {
+     }
- const char *pn = posix_names;
+   break;  /* Control never reaches here */
- register int yield = 0;
- while (posix_name_lengths[yield] != 0)
+   case PT_WORD:
-   {
+   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
-   if (len == posix_name_lengths[yield] &&
+           PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
-     STRNCMP_UC_C8(ptr, pn, len) == 0) return yield;
+           c == CHAR_UNDERSCORE) == negated;
-   pn += posix_name_lengths[yield] + 1;
-   yield++;
+   case PT_CLIST:
+   p = PRIV(ucd_caseless_sets) + prop->caseset;
+   for (;;)
+     {
+     if (c < *p) return !negated;
+     if (c == *p++) return negated;
+     }
+   break;  /* Control never reaches here */
    }
- return -1;
+ return FALSE;
  }
+ #endif  /* SUPPORT_UCP */
  /*************************************************
- *    Adjust OP_RECURSE items in repeated group   *
+ *        Fill the character property list        *
  *************************************************/
- /* OP_RECURSE items contain an offset from the start of the regex to the group
+ /* Checks whether the code points to an opcode that can take part in auto-
- that is referenced. This means that groups can be replicated for fixed
+ possessification, and if so, fills a list with its properties.
- repetition simply by copying (because the recursion is allowed to refer to
- earlier groups that are outside the current group). However, when a group is
- optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is
- inserted before it, after it has been compiled. This means that any OP_RECURSE
- items within it that refer to the group itself or any contained groups have to
- have their offsets adjusted. That one of the jobs of this function. Before it
- is called, the partially compiled regex must be temporarily terminated with
- OP_END.
- This function has been extended with the possibility of forward references for
- recursions and subroutine calls. It must also check the list of such references
- for the group we are dealing with. If it finds that one of the recursions in
- the current group is on this list, it adjusts the offset in the list, not the
- value in the reference (which is a group number).
  Arguments:
-   group      points to the start of the group
+   code        points to start of expression
-   adjust     the amount by which the group is to be moved
+   utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
-   utf        TRUE in UTF-8 / UTF-16 mode
+   fcc         points to case-flipping table
-   cd         contains pointers to tables etc.
+   list        points to output list
-   save_hwm   the hwm forward reference pointer at the start of the group
+               list[0] will be filled with the opcode
+               list[1] will be non-zero if this opcode
+                 can match an empty character string
+               list[2..7] depends on the opcode
- Returns:     nothing
+ Returns:      points to the start of the next opcode if *code is accepted
+               NULL if *code is not accepted
  */
- static void
+ static const pcre_uchar *
- adjust_recurse(pcre_uchar *group, int adjust, BOOL utf, compile_data *cd,
+ get_chr_property_list(const pcre_uchar *code, BOOL utf,
-   pcre_uchar *save_hwm)
+   const pcre_uint8 *fcc, pcre_uint32 *list)
  {
- pcre_uchar *ptr = group;
+ pcre_uchar c = *code;
+ pcre_uchar base;
+ const pcre_uchar *end;
+ pcre_uint32 chr;
- while ((ptr = (pcre_uchar *)find_recurse(ptr, utf)) != NULL)
+ #ifdef SUPPORT_UCP
+ pcre_uint32 *clist_dest;
+ const pcre_uint32 *clist_src;
+ #else
+ utf = utf;  /* Suppress "unused parameter" compiler warning */
+ #endif
+ list[0] = c;
+ list[1] = FALSE;
+ code++;
+ if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)
    {
-   int offset;
+   base = get_repeat_base(c);
-   pcre_uchar *hc;
+   c -= (base - OP_STAR);
-   /* See if this recursion is on the forward reference list. If so, adjust the
+   if (c == OP_UPTO || c == OP_MINUPTO || c == OP_EXACT || c == OP_POSUPTO)
-   reference. */
+     code += IMM2_SIZE;
+   list[1] = (c != OP_PLUS && c != OP_MINPLUS && c != OP_EXACT && c != OP_POSPLUS);
-   for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)
+   switch(base)
      {
-     offset = GET(hc, 0);
+     case OP_STAR:
-     if (cd->start_code + offset == ptr + 1)
+     list[0] = OP_CHAR;
-       {
+     break;
+     case OP_STARI:
+     list[0] = OP_CHARI;
+     break;
+     case OP_NOTSTAR:
+     list[0] = OP_NOT;
+     break;
+     case OP_NOTSTARI:
+     list[0] = OP_NOTI;
+     break;
+     case OP_TYPESTAR:
+     list[0] = *code;
+     code++;
+     break;
+     }
+   c = list[0];
+   }
+ switch(c)
+   {
+   case OP_NOT_DIGIT:
+   case OP_DIGIT:
+   case OP_NOT_WHITESPACE:
+   case OP_WHITESPACE:
+   case OP_NOT_WORDCHAR:
+   case OP_WORDCHAR:
+   case OP_ANY:
+   case OP_ALLANY:
+   case OP_ANYNL:
+   case OP_NOT_HSPACE:
+   case OP_HSPACE:
+   case OP_NOT_VSPACE:
+   case OP_VSPACE:
+   case OP_EXTUNI:
+   case OP_EODN:
+   case OP_EOD:
+   case OP_DOLL:
+   case OP_DOLLM:
+   return code;
+   case OP_CHAR:
+   case OP_NOT:
+   GETCHARINCTEST(chr, code);
+   list[2] = chr;
+   list[3] = NOTACHAR;
+   return code;
+   case OP_CHARI:
+   case OP_NOTI:
+   list[0] = (c == OP_CHARI) ? OP_CHAR : OP_NOT;
+   GETCHARINCTEST(chr, code);
+   list[2] = chr;
+ #ifdef SUPPORT_UCP
+   if (chr < 128 || (chr < 256 && !utf))
+     list[3] = fcc[chr];
+   else
+     list[3] = UCD_OTHERCASE(chr);
+ #elif defined SUPPORT_UTF || !defined COMPILE_PCRE8
+   list[3] = (chr < 256) ? fcc[chr] : chr;
+ #else
+   list[3] = fcc[chr];
+ #endif
+   /* The othercase might be the same value. */
+   if (chr == list[3])
+     list[3] = NOTACHAR;
+   else
+     list[4] = NOTACHAR;
+   return code;
+ #ifdef SUPPORT_UCP
+   case OP_PROP:
+   case OP_NOTPROP:
+   if (code[0] != PT_CLIST)
+     {
+     list[2] = code[0];
+     list[3] = code[1];
+     return code + 2;
+     }
+   /* Convert only if we have enough space. */
+   clist_src = PRIV(ucd_caseless_sets) + code[1];
+   clist_dest = list + 2;
+   code += 2;
+   do {
+      if (clist_dest >= list + 8)
+        {
+        /* Early return if there is not enough space. This should never
+        happen, since all clists are shorter than 5 character now. */
+        list[2] = code[0];
+        list[3] = code[1];
+        return code;
+        }
+      *clist_dest++ = *clist_src;
+      }
+   while(*clist_src++ != NOTACHAR);
+   /* All characters are stored. The terminating NOTACHAR
+   is copied form the clist itself. */
+   list[0] = (c == OP_PROP) ? OP_CHAR : OP_NOT;
+   return code;
+ #endif
+   case OP_NCLASS:
+   case OP_CLASS:
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+   case OP_XCLASS:
+   if (c == OP_XCLASS)
+     end = code + GET(code, 0) - 1;
+   else
+ #endif
+     end = code + 32 / sizeof(pcre_uchar);
+   switch(*end)
+     {
+     case OP_CRSTAR:
+     case OP_CRMINSTAR:
+     case OP_CRQUERY:
+     case OP_CRMINQUERY:
+     case OP_CRPOSSTAR:
+     case OP_CRPOSQUERY:
+     list[1] = TRUE;
+     end++;
+     break;
+     case OP_CRPLUS:
+     case OP_CRMINPLUS:
+     case OP_CRPOSPLUS:
+     end++;
+     break;
+     case OP_CRRANGE:
+     case OP_CRMINRANGE:
+     case OP_CRPOSRANGE:
+     list[1] = (GET2(end, 1) == 0);
+     end += 1 + 2 * IMM2_SIZE;
+     break;
+     }
+   list[2] = (pcre_uint32)(end - code);
+   return end;
+   }
+ return NULL;    /* Opcode not accepted */
+ }
+ /*************************************************
+ *    Scan further character sets for match       *
+ *************************************************/
+ /* Checks whether the base and the current opcode have a common character, in
+ which case the base cannot be possessified.
+ Arguments:
+   code        points to the byte code
+   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
+   cd          static compile data
+   base_list   the data list of the base opcode
+ Returns:      TRUE if the auto-possessification is possible
+ */
+ static BOOL
+ compare_opcodes(const pcre_uchar *code, BOOL utf, const compile_data *cd,
+   const pcre_uint32 *base_list, const pcre_uchar *base_end, int *rec_limit)
+ {
+ pcre_uchar c;
+ pcre_uint32 list[8];
+ const pcre_uint32 *chr_ptr;
+ const pcre_uint32 *ochr_ptr;
+ const pcre_uint32 *list_ptr;
+ const pcre_uchar *next_code;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+ const pcre_uchar *xclass_flags;
+ #endif
+ const pcre_uint8 *class_bitset;
+ const pcre_uint8 *set1, *set2, *set_end;
+ pcre_uint32 chr;
+ BOOL accepted, invert_bits;
+ BOOL entered_a_group = FALSE;
+ if (*rec_limit == 0) return FALSE;
+ --(*rec_limit);
+ /* Note: the base_list[1] contains whether the current opcode has greedy
+ (represented by a non-zero value) quantifier. This is a different from
+ other character type lists, which stores here that the character iterator
+ matches to an empty string (also represented by a non-zero value). */
+ for(;;)
+   {
+   /* All operations move the code pointer forward.
+   Therefore infinite recursions are not possible. */
+   c = *code;
+   /* Skip over callouts */
+   if (c == OP_CALLOUT)
+     {
+     code += PRIV(OP_lengths)[c];
+     continue;
+     }
+   if (c == OP_ALT)
+     {
+     do code += GET(code, 1); while (*code == OP_ALT);
+     c = *code;
+     }
+   switch(c)
+     {
+     case OP_END:
+     case OP_KETRPOS:
+     /* TRUE only in greedy case. The non-greedy case could be replaced by
+     an OP_EXACT, but it is probably not worth it. (And note that OP_EXACT
+     uses more memory, which we cannot get at this stage.) */
+     return base_list[1] != 0;
+     case OP_KET:
+     /* If the bracket is capturing, and referenced by an OP_RECURSE, or
+     it is an atomic sub-pattern (assert, once, etc.) the non-greedy case
+     cannot be converted to a possessive form. */
+     if (base_list[1] == 0) return FALSE;
+     switch(*(code - GET(code, 1)))
+       {
+       case OP_ASSERT:
+       case OP_ASSERT_NOT:
+       case OP_ASSERTBACK:
+       case OP_ASSERTBACK_NOT:
+       case OP_ONCE:
+       case OP_ONCE_NC:
+       /* Atomic sub-patterns and assertions can always auto-possessify their
+       last iterator. However, if the group was entered as a result of checking
+       a previous iterator, this is not possible. */
+       return !entered_a_group;
+       }
+     code += PRIV(OP_lengths)[c];
+     continue;
+     case OP_ONCE:
+     case OP_ONCE_NC:
+     case OP_BRA:
+     case OP_CBRA:
+     next_code = code + GET(code, 1);
+     code += PRIV(OP_lengths)[c];
+     while (*next_code == OP_ALT)
+       {
+       if (!compare_opcodes(code, utf, cd, base_list, base_end, rec_limit))
+         return FALSE;
+       code = next_code + 1 + LINK_SIZE;
+       next_code += GET(next_code, 1);
+       }
+     entered_a_group = TRUE;
+     continue;
+     case OP_BRAZERO:
+     case OP_BRAMINZERO:
+     next_code = code + 1;
+     if (*next_code != OP_BRA && *next_code != OP_CBRA
+         && *next_code != OP_ONCE && *next_code != OP_ONCE_NC) return FALSE;
+     do next_code += GET(next_code, 1); while (*next_code == OP_ALT);
+     /* The bracket content will be checked by the
+     OP_BRA/OP_CBRA case above. */
+     next_code += 1 + LINK_SIZE;
+     if (!compare_opcodes(next_code, utf, cd, base_list, base_end, rec_limit))
+       return FALSE;
+     code += PRIV(OP_lengths)[c];
+     continue;
+     default:
+     break;
+     }
+   /* Check for a supported opcode, and load its properties. */
+   code = get_chr_property_list(code, utf, cd->fcc, list);
+   if (code == NULL) return FALSE;    /* Unsupported */
+   /* If either opcode is a small character list, set pointers for comparing
+   characters from that list with another list, or with a property. */
+   if (base_list[0] == OP_CHAR)
+     {
+     chr_ptr = base_list + 2;
+     list_ptr = list;
+     }
+   else if (list[0] == OP_CHAR)
+     {
+     chr_ptr = list + 2;
+     list_ptr = base_list;
+     }
+   /* Character bitsets can also be compared to certain opcodes. */
+   else if (base_list[0] == OP_CLASS || list[0] == OP_CLASS
+ #ifdef COMPILE_PCRE8
+       /* In 8 bit, non-UTF mode, OP_CLASS and OP_NCLASS are the same. */
+       || (!utf && (base_list[0] == OP_NCLASS || list[0] == OP_NCLASS))
+ #endif
+       )
+     {
+ #ifdef COMPILE_PCRE8
+     if (base_list[0] == OP_CLASS || (!utf && base_list[0] == OP_NCLASS))
+ #else
+     if (base_list[0] == OP_CLASS)
+ #endif
+       {
+       set1 = (pcre_uint8 *)(base_end - base_list[2]);
+       list_ptr = list;
+       }
+     else
+       {
+       set1 = (pcre_uint8 *)(code - list[2]);
+       list_ptr = base_list;
+       }
+     invert_bits = FALSE;
+     switch(list_ptr[0])
+       {
+       case OP_CLASS:
+       case OP_NCLASS:
+       set2 = (pcre_uint8 *)
+         ((list_ptr == list ? code : base_end) - list_ptr[2]);
+       break;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+       case OP_XCLASS:
+       xclass_flags = (list_ptr == list ? code : base_end) - list_ptr[2] + LINK_SIZE;
+       if ((*xclass_flags & XCL_HASPROP) != 0) return FALSE;
+       if ((*xclass_flags & XCL_MAP) == 0)
+         {
+         /* No bits are set for characters < 256. */
+         if (list[1] == 0) return TRUE;
+         /* Might be an empty repeat. */
+         continue;
+         }
+       set2 = (pcre_uint8 *)(xclass_flags + 1);
+       break;
+ #endif
+       case OP_NOT_DIGIT:
+       invert_bits = TRUE;
+       /* Fall through */
+       case OP_DIGIT:
+       set2 = (pcre_uint8 *)(cd->cbits + cbit_digit);
+       break;
+       case OP_NOT_WHITESPACE:
+       invert_bits = TRUE;
+       /* Fall through */
+       case OP_WHITESPACE:
+       set2 = (pcre_uint8 *)(cd->cbits + cbit_space);
+       break;
+       case OP_NOT_WORDCHAR:
+       invert_bits = TRUE;
+       /* Fall through */
+       case OP_WORDCHAR:
+       set2 = (pcre_uint8 *)(cd->cbits + cbit_word);
+       break;
+       default:
+       return FALSE;
+       }
+     /* Because the sets are unaligned, we need
+     to perform byte comparison here. */
+     set_end = set1 + 32;
+     if (invert_bits)
+       {
+       do
+         {
+         if ((*set1++ & ~(*set2++)) != 0) return FALSE;
+         }
+       while (set1 < set_end);
+       }
+     else
+       {
+       do
+         {
+         if ((*set1++ & *set2++) != 0) return FALSE;
+         }
+       while (set1 < set_end);
+       }
+     if (list[1] == 0) return TRUE;
+     /* Might be an empty repeat. */
+     continue;
+     }
+   /* Some property combinations also acceptable. Unicode property opcodes are
+   processed specially; the rest can be handled with a lookup table. */
+   else
+     {
+     pcre_uint32 leftop, rightop;
+     leftop = base_list[0];
+     rightop = list[0];
+ #ifdef SUPPORT_UCP
+     accepted = FALSE; /* Always set in non-unicode case. */
+     if (leftop == OP_PROP || leftop == OP_NOTPROP)
+       {
+       if (rightop == OP_EOD)
+         accepted = TRUE;
+       else if (rightop == OP_PROP || rightop == OP_NOTPROP)
+         {
+         int n;
+         const pcre_uint8 *p;
+         BOOL same = leftop == rightop;
+         BOOL lisprop = leftop == OP_PROP;
+         BOOL risprop = rightop == OP_PROP;
+         BOOL bothprop = lisprop && risprop;
+         /* There's a table that specifies how each combination is to be
+         processed:
+  Always return FALSE (never auto-possessify)
+  Character groups are distinct (possessify if both are OP_PROP)
+  Check character categories in the same group (general or particular)
+  Return TRUE if the two opcodes are not the same
+           ... see comments below
+         */
+         n = propposstab[base_list[2]][list[2]];
+         switch(n)
+           {
+           case 0: break;
+           case 1: accepted = bothprop; break;
+           case 2: accepted = (base_list[3] == list[3]) != same; break;
+           case 3: accepted = !same; break;
+           case 4:  /* Left general category, right particular category */
+           accepted = risprop && catposstab[base_list[3]][list[3]] == same;
+           break;
+           case 5:  /* Right general category, left particular category */
+           accepted = lisprop && catposstab[list[3]][base_list[3]] == same;
+           break;
+           /* This code is logically tricky. Think hard before fiddling with it.
+           The posspropstab table has four entries per row. Each row relates to
+           one of PCRE's special properties such as ALNUM or SPACE or WORD.
+           Only WORD actually needs all four entries, but using repeats for the
+           others means they can all use the same code below.
+           The first two entries in each row are Unicode general categories, and
+           apply always, because all the characters they include are part of the
+           PCRE character set. The third and fourth entries are a general and a
+           particular category, respectively, that include one or more relevant
+           characters. One or the other is used, depending on whether the check
+           is for a general or a particular category. However, in both cases the
+           category contains more characters than the specials that are defined
+           for the property being tested against. Therefore, it cannot be used
+           in a NOTPROP case.
+           Example: the row for WORD contains ucp_L, ucp_N, ucp_P, ucp_Po.
+           Underscore is covered by ucp_P or ucp_Po. */
+           case 6:  /* Left alphanum vs right general category */
+           case 7:  /* Left space vs right general category */
+           case 8:  /* Left word vs right general category */
+           p = posspropstab[n-6];
+           accepted = risprop && lisprop ==
+             (list[3] != p[0] &&
+              list[3] != p[1] &&
+             (list[3] != p[2] || !lisprop));
+           break;
+           case 9:   /* Right alphanum vs left general category */
+           case 10:  /* Right space vs left general category */
+           case 11:  /* Right word vs left general category */
+           p = posspropstab[n-9];
+           accepted = lisprop && risprop ==
+             (base_list[3] != p[0] &&
+              base_list[3] != p[1] &&
+             (base_list[3] != p[2] || !risprop));
+           break;
+           case 12:  /* Left alphanum vs right particular category */
+           case 13:  /* Left space vs right particular category */
+           case 14:  /* Left word vs right particular category */
+           p = posspropstab[n-12];
+           accepted = risprop && lisprop ==
+             (catposstab[p[0]][list[3]] &&
+              catposstab[p[1]][list[3]] &&
+             (list[3] != p[3] || !lisprop));
+           break;
+           case 15:  /* Right alphanum vs left particular category */
+           case 16:  /* Right space vs left particular category */
+           case 17:  /* Right word vs left particular category */
+           p = posspropstab[n-15];
+           accepted = lisprop && risprop ==
+             (catposstab[p[0]][base_list[3]] &&
+              catposstab[p[1]][base_list[3]] &&
+             (base_list[3] != p[3] || !risprop));
+           break;
+           }
+         }
+       }
+     else
+ #endif  /* SUPPORT_UCP */
+     accepted = leftop >= FIRST_AUTOTAB_OP && leftop <= LAST_AUTOTAB_LEFT_OP &&
+            rightop >= FIRST_AUTOTAB_OP && rightop <= LAST_AUTOTAB_RIGHT_OP &&
+            autoposstab[leftop - FIRST_AUTOTAB_OP][rightop - FIRST_AUTOTAB_OP];
+     if (!accepted) return FALSE;
+     if (list[1] == 0) return TRUE;
+     /* Might be an empty repeat. */
+     continue;
+     }
+   /* Control reaches here only if one of the items is a small character list.
+   All characters are checked against the other side. */
+   do
+     {
+     chr = *chr_ptr;
+     switch(list_ptr[0])
+       {
+       case OP_CHAR:
+       ochr_ptr = list_ptr + 2;
+       do
+         {
+         if (chr == *ochr_ptr) return FALSE;
+         ochr_ptr++;
+         }
+       while(*ochr_ptr != NOTACHAR);
+       break;
+       case OP_NOT:
+       ochr_ptr = list_ptr + 2;
+       do
+         {
+         if (chr == *ochr_ptr)
+           break;
+         ochr_ptr++;
+         }
+       while(*ochr_ptr != NOTACHAR);
+       if (*ochr_ptr == NOTACHAR) return FALSE;   /* Not found */
+       break;
+       /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not*
+       set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
+       case OP_DIGIT:
+       if (chr < 256 && (cd->ctypes[chr] & ctype_digit) != 0) return FALSE;
+       break;
+       case OP_NOT_DIGIT:
+       if (chr > 255 || (cd->ctypes[chr] & ctype_digit) == 0) return FALSE;
+       break;
+       case OP_WHITESPACE:
+       if (chr < 256 && (cd->ctypes[chr] & ctype_space) != 0) return FALSE;
+       break;
+       case OP_NOT_WHITESPACE:
+       if (chr > 255 || (cd->ctypes[chr] & ctype_space) == 0) return FALSE;
+       break;
+       case OP_WORDCHAR:
+       if (chr < 255 && (cd->ctypes[chr] & ctype_word) != 0) return FALSE;
+       break;
+       case OP_NOT_WORDCHAR:
+       if (chr > 255 || (cd->ctypes[chr] & ctype_word) == 0) return FALSE;
+       break;
+       case OP_HSPACE:
+       switch(chr)
+         {
+         HSPACE_CASES: return FALSE;
+         default: break;
+         }
+       break;
+       case OP_NOT_HSPACE:
+       switch(chr)
+         {
+         HSPACE_CASES: break;
+         default: return FALSE;
+         }
+       break;
+       case OP_ANYNL:
+       case OP_VSPACE:
+       switch(chr)
+         {
+         VSPACE_CASES: return FALSE;
+         default: break;
+         }
+       break;
+       case OP_NOT_VSPACE:
+       switch(chr)
+         {
+         VSPACE_CASES: break;
+         default: return FALSE;
+         }
+       break;
+       case OP_DOLL:
+       case OP_EODN:
+       switch (chr)
+         {
+         case CHAR_CR:
+         case CHAR_LF:
+         case CHAR_VT:
+         case CHAR_FF:
+         case CHAR_NEL:
+ #ifndef EBCDIC
+         case 0x2028:
+         case 0x2029:
+ #endif  /* Not EBCDIC */
+         return FALSE;
+         }
+       break;
+       case OP_EOD:    /* Can always possessify before \z */
+       break;
+ #ifdef SUPPORT_UCP
+       case OP_PROP:
+       case OP_NOTPROP:
+       if (!check_char_prop(chr, list_ptr[2], list_ptr[3],
+             list_ptr[0] == OP_NOTPROP))
+         return FALSE;
+       break;
+ #endif
+       case OP_NCLASS:
+       if (chr > 255) return FALSE;
+       /* Fall through */
+       case OP_CLASS:
+       if (chr > 255) break;
+       class_bitset = (pcre_uint8 *)
+         ((list_ptr == list ? code : base_end) - list_ptr[2]);
+       if ((class_bitset[chr >> 3] & (1 << (chr & 7))) != 0) return FALSE;
+       break;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+       case OP_XCLASS:
+       if (PRIV(xclass)(chr, (list_ptr == list ? code : base_end) -
+           list_ptr[2] + LINK_SIZE, utf)) return FALSE;
+       break;
+ #endif
+       default:
+       return FALSE;
+       }
+     chr_ptr++;
+     }
+   while(*chr_ptr != NOTACHAR);
+   /* At least one character must be matched from this opcode. */
+   if (list[1] == 0) return TRUE;
+   }
+ /* Control never reaches here. There used to be a fail-save return FALSE; here,
+ but some compilers complain about an unreachable statement. */
+ }
+ /*************************************************
+ *    Scan compiled regex for auto-possession     *
+ *************************************************/
+ /* Replaces single character iterations with their possessive alternatives
+ if appropriate. This function modifies the compiled opcode!
+ Arguments:
+   code        points to start of the byte code
+   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
+   cd          static compile data
+ Returns:      nothing
+ */
+ static void
+ auto_possessify(pcre_uchar *code, BOOL utf, const compile_data *cd)
+ {
+ register pcre_uchar c;
+ const pcre_uchar *end;
+ pcre_uchar *repeat_opcode;
+ pcre_uint32 list[8];
+ int rec_limit;
+ for (;;)
+   {
+   c = *code;
+   /* When a pattern with bad UTF-8 encoding is compiled with NO_UTF_CHECK,
+   it may compile without complaining, but may get into a loop here if the code
+   pointer points to a bad value. This is, of course a documentated possibility,
+   when NO_UTF_CHECK is set, so it isn't a bug, but we can detect this case and
+   just give up on this optimization. */
+   if (c >= OP_TABLE_LENGTH) return;
+   if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)
+     {
+     c -= get_repeat_base(c) - OP_STAR;
+     end = (c <= OP_MINUPTO) ?
+       get_chr_property_list(code, utf, cd->fcc, list) : NULL;
+     list[1] = c == OP_STAR || c == OP_PLUS || c == OP_QUERY || c == OP_UPTO;
+     rec_limit = 10000;
+     if (end != NULL && compare_opcodes(end, utf, cd, list, end, &rec_limit))
+       {
+       switch(c)
+         {
+         case OP_STAR:
+         *code += OP_POSSTAR - OP_STAR;
+         break;
+         case OP_MINSTAR:
+         *code += OP_POSSTAR - OP_MINSTAR;
+         break;
+         case OP_PLUS:
+         *code += OP_POSPLUS - OP_PLUS;
+         break;
+         case OP_MINPLUS:
+         *code += OP_POSPLUS - OP_MINPLUS;
+         break;
+         case OP_QUERY:
+         *code += OP_POSQUERY - OP_QUERY;
+         break;
+         case OP_MINQUERY:
+         *code += OP_POSQUERY - OP_MINQUERY;
+         break;
+         case OP_UPTO:
+         *code += OP_POSUPTO - OP_UPTO;
+         break;
+         case OP_MINUPTO:
+         *code += OP_POSUPTO - OP_MINUPTO;
+         break;
+         }
+       }
+     c = *code;
+     }
+   else if (c == OP_CLASS || c == OP_NCLASS || c == OP_XCLASS)
+     {
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     if (c == OP_XCLASS)
+       repeat_opcode = code + GET(code, 1);
+     else
+ #endif
+       repeat_opcode = code + 1 + (32 / sizeof(pcre_uchar));
+     c = *repeat_opcode;
+     if (c >= OP_CRSTAR && c <= OP_CRMINRANGE)
+       {
+       /* end must not be NULL. */
+       end = get_chr_property_list(code, utf, cd->fcc, list);
+       list[1] = (c & 1) == 0;
+       rec_limit = 10000;
+       if (compare_opcodes(end, utf, cd, list, end, &rec_limit))
+         {
+         switch (c)
+           {
+           case OP_CRSTAR:
+           case OP_CRMINSTAR:
+           *repeat_opcode = OP_CRPOSSTAR;
+           break;
+           case OP_CRPLUS:
+           case OP_CRMINPLUS:
+           *repeat_opcode = OP_CRPOSPLUS;
+           break;
+           case OP_CRQUERY:
+           case OP_CRMINQUERY:
+           *repeat_opcode = OP_CRPOSQUERY;
+           break;
+           case OP_CRRANGE:
+           case OP_CRMINRANGE:
+           *repeat_opcode = OP_CRPOSRANGE;
+           break;
+           }
+         }
+       }
+     c = *code;
+     }
+   switch(c)
+     {
+     case OP_END:
+     return;
+     case OP_TYPESTAR:
+     case OP_TYPEMINSTAR:
+     case OP_TYPEPLUS:
+     case OP_TYPEMINPLUS:
+     case OP_TYPEQUERY:
+     case OP_TYPEMINQUERY:
+     case OP_TYPEPOSSTAR:
+     case OP_TYPEPOSPLUS:
+     case OP_TYPEPOSQUERY:
+     if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
+     break;
+     case OP_TYPEUPTO:
+     case OP_TYPEMINUPTO:
+     case OP_TYPEEXACT:
+     case OP_TYPEPOSUPTO:
+     if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
+       code += 2;
+     break;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     case OP_XCLASS:
+     code += GET(code, 1);
+     break;
+ #endif
+     case OP_MARK:
+     case OP_PRUNE_ARG:
+     case OP_SKIP_ARG:
+     case OP_THEN_ARG:
+     code += code[1];
+     break;
+     }
+   /* Add in the fixed length from the table */
+   code += PRIV(OP_lengths)[c];
+   /* In UTF-8 mode, opcodes that are followed by a character may be followed by
+   a multi-byte character. The length in the table is a minimum, so we have to
+   arrange to skip the extra bytes. */
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+   if (utf) switch(c)
+     {
+     case OP_CHAR:
+     case OP_CHARI:
+     case OP_NOT:
+     case OP_NOTI:
+     case OP_STAR:
+     case OP_MINSTAR:
+     case OP_PLUS:
+     case OP_MINPLUS:
+     case OP_QUERY:
+     case OP_MINQUERY:
+     case OP_UPTO:
+     case OP_MINUPTO:
+     case OP_EXACT:
+     case OP_POSSTAR:
+     case OP_POSPLUS:
+     case OP_POSQUERY:
+     case OP_POSUPTO:
+     case OP_STARI:
+     case OP_MINSTARI:
+     case OP_PLUSI:
+     case OP_MINPLUSI:
+     case OP_QUERYI:
+     case OP_MINQUERYI:
+     case OP_UPTOI:
+     case OP_MINUPTOI:
+     case OP_EXACTI:
+     case OP_POSSTARI:
+     case OP_POSPLUSI:
+     case OP_POSQUERYI:
+     case OP_POSUPTOI:
+     case OP_NOTSTAR:
+     case OP_NOTMINSTAR:
+     case OP_NOTPLUS:
+     case OP_NOTMINPLUS:
+     case OP_NOTQUERY:
+     case OP_NOTMINQUERY:
+     case OP_NOTUPTO:
+     case OP_NOTMINUPTO:
+     case OP_NOTEXACT:
+     case OP_NOTPOSSTAR:
+     case OP_NOTPOSPLUS:
+     case OP_NOTPOSQUERY:
+     case OP_NOTPOSUPTO:
+     case OP_NOTSTARI:
+     case OP_NOTMINSTARI:
+     case OP_NOTPLUSI:
+     case OP_NOTMINPLUSI:
+     case OP_NOTQUERYI:
+     case OP_NOTMINQUERYI:
+     case OP_NOTUPTOI:
+     case OP_NOTMINUPTOI:
+     case OP_NOTEXACTI:
+     case OP_NOTPOSSTARI:
+     case OP_NOTPOSPLUSI:
+     case OP_NOTPOSQUERYI:
+     case OP_NOTPOSUPTOI:
+     if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
+     break;
+     }
+ #else
+   (void)(utf);  /* Keep compiler happy by referencing function argument */
+ #endif
+   }
+ }
+ /*************************************************
+ *           Check for POSIX class syntax         *
+ *************************************************/
+ /* This function is called when the sequence "[:" or "[." or "[=" is
+ encountered in a character class. It checks whether this is followed by a
+ sequence of characters terminated by a matching ":]" or ".]" or "=]". If we
+ reach an unescaped ']' without the special preceding character, return FALSE.
+ Originally, this function only recognized a sequence of letters between the
+ terminators, but it seems that Perl recognizes any sequence of characters,
+ though of course unknown POSIX names are subsequently rejected. Perl gives an
+ "Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE
+ didn't consider this to be a POSIX class. Likewise for [:1234:].
+ The problem in trying to be exactly like Perl is in the handling of escapes. We
+ have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
+ class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
+ below handles the special case of \], but does not try to do any other escape
+ processing. This makes it different from Perl for cases such as [:l\ower:]
+ where Perl recognizes it as the POSIX class "lower" but PCRE does not recognize
+ "l\ower". This is a lesser evil than not diagnosing bad classes when Perl does,
+ I think.
+ A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not.
+ It seems that the appearance of a nested POSIX class supersedes an apparent
+ external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or
+ a digit.
+ In Perl, unescaped square brackets may also appear as part of class names. For
+ example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for
+ [:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not
+ seem right at all. PCRE does not allow closing square brackets in POSIX class
+ names.
+ Arguments:
+   ptr      pointer to the initial [
+   endptr   where to return the end pointer
+ Returns:   TRUE or FALSE
+ */
+ static BOOL
+ check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr)
+ {
+ pcre_uchar terminator;          /* Don't combine these lines; the Solaris cc */
+ terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
+ for (++ptr; *ptr != CHAR_NULL; ptr++)
+   {
+   if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
+     ptr++;
+   else if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
+   else
+     {
+     if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
+       {
+       *endptr = ptr;
+       return TRUE;
+       }
+     if (*ptr == CHAR_LEFT_SQUARE_BRACKET &&
+          (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
+           ptr[1] == CHAR_EQUALS_SIGN) &&
+         check_posix_syntax(ptr, endptr))
+       return FALSE;
+     }
+   }
+ return FALSE;
+ }
+ /*************************************************
+ *          Check POSIX class name                *
+ *************************************************/
+ /* This function is called to check the name given in a POSIX-style class entry
+ such as [:alnum:].
+ Arguments:
+   ptr        points to the first letter
+   len        the length of the name
+ Returns:     a value representing the name, or -1 if unknown
+ */
+ static int
+ check_posix_name(const pcre_uchar *ptr, int len)
+ {
+ const char *pn = posix_names;
+ register int yield = 0;
+ while (posix_name_lengths[yield] != 0)
+   {
+   if (len == posix_name_lengths[yield] &&
+     STRNCMP_UC_C8(ptr, pn, (unsigned int)len) == 0) return yield;
+   pn += posix_name_lengths[yield] + 1;
+   yield++;
+   }
+ return -1;
+ }
+ /*************************************************
+ *    Adjust OP_RECURSE items in repeated group   *
+ *************************************************/
+ /* OP_RECURSE items contain an offset from the start of the regex to the group
+ that is referenced. This means that groups can be replicated for fixed
+ repetition simply by copying (because the recursion is allowed to refer to
+ earlier groups that are outside the current group). However, when a group is
+ optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is
+ inserted before it, after it has been compiled. This means that any OP_RECURSE
+ items within it that refer to the group itself or any contained groups have to
+ have their offsets adjusted. That one of the jobs of this function. Before it
+ is called, the partially compiled regex must be temporarily terminated with
+ OP_END.
+ This function has been extended with the possibility of forward references for
+ recursions and subroutine calls. It must also check the list of such references
+ for the group we are dealing with. If it finds that one of the recursions in
+ the current group is on this list, it adjusts the offset in the list, not the
+ value in the reference (which is a group number).
+ Arguments:
+   group      points to the start of the group
+   adjust     the amount by which the group is to be moved
+   utf        TRUE in UTF-8 / UTF-16 / UTF-32 mode
+   cd         contains pointers to tables etc.
+   save_hwm_offset   the hwm forward reference offset at the start of the group
+ Returns:     nothing
+ */
+ static void
+ adjust_recurse(pcre_uchar *group, int adjust, BOOL utf, compile_data *cd,
+   size_t save_hwm_offset)
+ {
+ pcre_uchar *ptr = group;
+ while ((ptr = (pcre_uchar *)find_recurse(ptr, utf)) != NULL)
+   {
+   int offset;
+   pcre_uchar *hc;
+   /* See if this recursion is on the forward reference list. If so, adjust the
+   reference. */
+   for (hc = (pcre_uchar *)cd->start_workspace + save_hwm_offset; hc < cd->hwm;
+        hc += LINK_SIZE)
+     {
+     offset = (int)GET(hc, 0);
+     if (cd->start_code + offset == ptr + 1)
+       {
        PUT(hc, 0, offset + adjust);
        break;
        }
-Line 2760 
 while ((ptr = (pcre_uchar *)find_recurse
+Line 4025 
 while ((ptr = (pcre_uchar *)find_recurse
    if (hc >= cd->hwm)
      {
-     offset = GET(ptr, 1);
+     offset = (int)GET(ptr, 1);
      if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
      }
-Line 2828 
 PUT(previous_callout, 2 + LINK_SIZE, len
+Line 4093 
 PUT(previous_callout, 2 + LINK_SIZE, len
  *************************************************/
  /* This function is passed the start and end of a class range, in UTF-8 mode
- with UCP support. It searches up the characters, looking for internal ranges of
+ with UCP support. It searches up the characters, looking for ranges of
  characters in the "other" case. Each call returns the next one, updating the
- start address.
+ start address. A character with multiple other cases is returned on its own
+ with a special return value.
  Arguments:
    cptr        points to starting character value; updated
-Line 2838 
 Arguments:
+Line 4104 
 Arguments:
    ocptr       where to put start of othercase range
    odptr       where to put end of othercase range
- Yield:        TRUE when range returned; FALSE when no more
+ Yield:        -1 when no more
- */
+when a range is returned
+               >0 the CASESET offset for char with multiple other cases
- static BOOL
+                 in this case, ocptr contains the original
- get_othercase_range(unsigned int *cptr, unsigned int d, unsigned int *ocptr,
-   unsigned int *odptr)
- {
- unsigned int c, othercase, next;
- for (c = *cptr; c <= d; c++)
-   { if ((othercase = UCD_OTHERCASE(c)) != c) break; }
- if (c > d) return FALSE;
- *ocptr = othercase;
- next = othercase + 1;
- for (++c; c <= d; c++)
-   {
-   if (UCD_OTHERCASE(c) != next) break;
-   next++;
-   }
- *odptr = next - 1;
- *cptr = c;
- return TRUE;
- }
- /*************************************************
- *        Check a character and a property        *
- *************************************************/
- /* This function is called by check_auto_possessive() when a property item
- is adjacent to a fixed character.
- Arguments:
-   c            the character
-   ptype        the property type
-   pdata        the data for the type
-   negated      TRUE if it's a negated property (\P or \p{^)
- Returns:       TRUE if auto-possessifying is OK
- */
- static BOOL
- check_char_prop(int c, int ptype, int pdata, BOOL negated)
- {
- const ucd_record *prop = GET_UCD(c);
- switch(ptype)
-   {
-   case PT_LAMP:
-   return (prop->chartype == ucp_Lu ||
-           prop->chartype == ucp_Ll ||
-           prop->chartype == ucp_Lt) == negated;
-   case PT_GC:
-   return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;
-   case PT_PC:
-   return (pdata == prop->chartype) == negated;
-   case PT_SC:
-   return (pdata == prop->script) == negated;
-   /* These are specials */
-   case PT_ALNUM:
-   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
-           PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;
-   case PT_SPACE:    /* Perl space */
-   return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
-           c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
-           == negated;
-   case PT_PXSPACE:  /* POSIX space */
-   return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
-           c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
-           c == CHAR_FF || c == CHAR_CR)
-           == negated;
-   case PT_WORD:
-   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
-           PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
-           c == CHAR_UNDERSCORE) == negated;
-   }
- return FALSE;
- }
- #endif  /* SUPPORT_UCP */
- /*************************************************
- *     Check if auto-possessifying is possible    *
- *************************************************/
- /* This function is called for unlimited repeats of certain items, to see
- whether the next thing could possibly match the repeated item. If not, it makes
- sense to automatically possessify the repeated item.
- Arguments:
-   previous      pointer to the repeated opcode
-   utf           TRUE in UTF-8 / UTF-16 mode
-   ptr           next character in pattern
-   options       options bits
-   cd            contains pointers to tables etc.
- Returns:        TRUE if possessifying is wanted
  */
- static BOOL
+ static int
- check_auto_possessive(const pcre_uchar *previous, BOOL utf,
+ get_othercase_range(pcre_uint32 *cptr, pcre_uint32 d, pcre_uint32 *ocptr,
-   const pcre_uchar *ptr, int options, compile_data *cd)
+   pcre_uint32 *odptr)
  {
- pcre_int32 c, next;
+ pcre_uint32 c, othercase, next;
- int op_code = *previous++;
+ unsigned int co;
- /* Skip whitespace and comments in extended mode */
+ /* Find the first character that has an other case. If it has multiple other
+ cases, return its case offset value. */
- if ((options & PCRE_EXTENDED) != 0)
+ for (c = *cptr; c <= d; c++)
    {
-   for (;;)
+   if ((co = UCD_CASESET(c)) != 0)
      {
-     while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
+     *ocptr = c++;   /* Character that has the set */
-     if (*ptr == CHAR_NUMBER_SIGN)
+     *cptr = c;      /* Rest of input range */
-       {
+     return (int)co;
-       ptr++;
-       while (*ptr != 0)
-         {
-         if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
-         ptr++;
- #ifdef SUPPORT_UTF
-         if (utf) FORWARDCHAR(ptr);
- #endif
-         }
-       }
-     else break;
      }
+   if ((othercase = UCD_OTHERCASE(c)) != c) break;
    }
- /* If the next item is one that we can handle, get its value. A non-negative
+ if (c > d) return -1;  /* Reached end of range */
- value is a character, a negative value is an escape value. */
- if (*ptr == CHAR_BACKSLASH)
+ /* Found a character that has a single other case. Search for the end of the
-   {
+ range, which is either the end of the input range, or a character that has zero
-   int temperrorcode = 0;
+ or more than one other cases. */
-   next = check_escape(&ptr, &temperrorcode, cd->bracount, options, FALSE);
-   if (temperrorcode != 0) return FALSE;
-   ptr++;    /* Point after the escape sequence */
-   }
- else if (!MAX_255(*ptr) || (cd->ctypes[*ptr] & ctype_meta) == 0)
-   {
- #ifdef SUPPORT_UTF
-   if (utf) { GETCHARINC(next, ptr); } else
- #endif
-   next = *ptr++;
-   }
- else return FALSE;
- /* Skip whitespace and comments in extended mode */
+ *ocptr = othercase;
+ next = othercase + 1;
- if ((options & PCRE_EXTENDED) != 0)
+ for (++c; c <= d; c++)
    {
-   for (;;)
+   if ((co = UCD_CASESET(c)) != 0 || UCD_OTHERCASE(c) != next) break;
-     {
+   next++;
-     while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
-     if (*ptr == CHAR_NUMBER_SIGN)
-       {
-       ptr++;
-       while (*ptr != 0)
-         {
-         if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
-         ptr++;
- #ifdef SUPPORT_UTF
-         if (utf) FORWARDCHAR(ptr);
- #endif
-         }
-       }
-     else break;
-     }
    }
- /* If the next thing is itself optional, we have to give up. */
+ *odptr = next - 1;     /* End of othercase range */
+ *cptr = c;             /* Rest of input range */
+ return 0;
+ }
+ #endif  /* SUPPORT_UCP */
- if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||
-   STRNCMP_UC_C8(ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
-     return FALSE;
- /* Now compare the next item with the previous opcode. First, handle cases when
- the next item is a character. */
- if (next >= 0) switch(op_code)
+ /*************************************************
-   {
+ *        Add a character or range to a class     *
-   case OP_CHAR:
+ *************************************************/
- #ifdef SUPPORT_UTF
-   GETCHARTEST(c, previous);
- #else
-   c = *previous;
- #endif
-   return c != next;
-   /* For CHARI (caseless character) we must check the other case. If we have
+ /* This function packages up the logic of adding a character or range of
-   Unicode property support, we can use it to test the other case of
+ characters to a class. The character values in the arguments will be within the
-   high-valued characters. */
+ valid values for the current mode (8-bit, 16-bit, UTF, etc). This function is
+ mutually recursive with the function immediately below.
-   case OP_CHARI:
+ Arguments:
- #ifdef SUPPORT_UTF
+   classbits     the bit map for characters < 256
-   GETCHARTEST(c, previous);
+   uchardptr     points to the pointer for extra data
- #else
+   options       the options word
-   c = *previous;
+   cd            contains pointers to tables etc.
- #endif
+   start         start of range character
-   if (c == next) return FALSE;
+   end           end of range character
- #ifdef SUPPORT_UTF
-   if (utf)
-     {
-     unsigned int othercase;
-     if (next < 128) othercase = cd->fcc[next]; else
- #ifdef SUPPORT_UCP
-     othercase = UCD_OTHERCASE((unsigned int)next);
- #else
-     othercase = NOTACHAR;
- #endif
-     return (unsigned int)c != othercase;
-     }
-   else
- #endif  /* SUPPORT_UTF */
-   return (c != TABLE_GET(next, cd->fcc, next));  /* Non-UTF-8 mode */
-   /* For OP_NOT and OP_NOTI, the data is always a single-byte character. These
+ Returns:        the number of < 256 characters added
-   opcodes are not used for multi-byte characters, because they are coded using
+                 the pointer to extra data is updated
-   an XCLASS instead. */
+ */
-   case OP_NOT:
+ static int
-   return (c = *previous) == next;
+ add_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,
+   compile_data *cd, pcre_uint32 start, pcre_uint32 end)
+ {
+ pcre_uint32 c;
+ pcre_uint32 classbits_end = (end <= 0xff ? end : 0xff);
+ int n8 = 0;
+ /* If caseless matching is required, scan the range and process alternate
+ cases. In Unicode, there are 8-bit characters that have alternate cases that
+ are greater than 255 and vice-versa. Sometimes we can just extend the original
+ range. */
-   case OP_NOTI:
+ if ((options & PCRE_CASELESS) != 0)
-   if ((c = *previous) == next) return TRUE;
+   {
- #ifdef SUPPORT_UTF
-   if (utf)
-     {
-     unsigned int othercase;
-     if (next < 128) othercase = cd->fcc[next]; else
  #ifdef SUPPORT_UCP
-     othercase = UCD_OTHERCASE(next);
+   if ((options & PCRE_UTF8) != 0)
- #else
+     {
-     othercase = NOTACHAR;
+     int rc;
- #endif
+     pcre_uint32 oc, od;
-     return (unsigned int)c == othercase;
-     }
-   else
- #endif  /* SUPPORT_UTF */
-   return (c == TABLE_GET(next, cd->fcc, next));  /* Non-UTF-8 mode */
-   /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not* set.
-   When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
-   case OP_DIGIT:
+     options &= ~PCRE_CASELESS;   /* Remove for recursive calls */
-   return next > 127 || (cd->ctypes[next] & ctype_digit) == 0;
+     c = start;
-   case OP_NOT_DIGIT:
+     while ((rc = get_othercase_range(&c, end, &oc, &od)) >= 0)
-   return next <= 127 && (cd->ctypes[next] & ctype_digit) != 0;
+       {
+       /* Handle a single character that has more than one other case. */
-   case OP_WHITESPACE:
+       if (rc > 0) n8 += add_list_to_class(classbits, uchardptr, options, cd,
-   return next > 127 || (cd->ctypes[next] & ctype_space) == 0;
+         PRIV(ucd_caseless_sets) + rc, oc);
-   case OP_NOT_WHITESPACE:
+       /* Do nothing if the other case range is within the original range. */
-   return next <= 127 && (cd->ctypes[next] & ctype_space) != 0;
-   case OP_WORDCHAR:
+       else if (oc >= start && od <= end) continue;
-   return next > 127 || (cd->ctypes[next] & ctype_word) == 0;
-   case OP_NOT_WORDCHAR:
+       /* Extend the original range if there is overlap, noting that if oc < c, we
-   return next <= 127 && (cd->ctypes[next] & ctype_word) != 0;
+       can't have od > end because a subrange is always shorter than the basic
+       range. Otherwise, use a recursive call to add the additional range. */
-   case OP_HSPACE:
+       else if (oc < start && od >= start - 1) start = oc; /* Extend downwards */
-   case OP_NOT_HSPACE:
+       else if (od > end && oc <= end + 1)
-   switch(next)
+         {
-     {
+         end = od;       /* Extend upwards */
-     case 0x09:
+         if (end > classbits_end) classbits_end = (end <= 0xff ? end : 0xff);
-     case 0x20:
+         }
-     case 0xa0:
+       else n8 += add_to_class(classbits, uchardptr, options, cd, oc, od);
-     case 0x1680:
+       }
-     case 0x180e: