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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 1361 by ph10,
Fri Sep  6 17:47:32 2013 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-2013 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"
 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
 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 275 
 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 302 
 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 329 
 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 382 
 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 397 
 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 462 
 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 516 
 static const char error_texts[] =
+Line 540 
 static const char error_texts[] =
    "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 655 
 static const pcre_uint8 ebcdic_chartab[]
+Line 689 
 static const pcre_uint8 ebcdic_chartab[]
  #endif
+ /* 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 */
+ };
+ /* This table is used to check whether auto-possessification is possible
+ between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP). The
+ 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 */
+ };
  /*************************************************
  *            Find an error text                  *
-Line 682 
 return s;
+Line 893 
 return s;
  }
  /*************************************************
  *           Expand the workspace                 *
  *************************************************/
-Line 759 
 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 0 for a data character
+ positive value for a simple escape such as \n, or 0 for a data character which
- which will be placed in chptr. A backreference to group n is returned as
+ will be placed in chptr. A backreference to group n is returned as negative n.
- negative n. When UTF-8 is enabled, a positive value greater than 255 may
+ When UTF-8 is enabled, a positive value greater than 255 may be returned in
- be returned in chptr.
+ chptr. On entry, ptr is pointing at the \. On exit, it is on the final
- On entry,ptr is pointing at the \. On exit, it is on the final character of the
+ character of the escape sequence.
- escape sequence.
  Arguments:
    ptrptr         points to the pattern position pointer
-   chptr          points to the data character
+   chptr          points to a returned data character
    errorcodeptr   points to the errorcode variable
    bracount       number of previous extracting brackets
    options        the options bits
-Line 972 
 else
+Line 1183 
 else
      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 1008 
 else
+Line 1223 
 else
          *errorcodeptr = ERR61;
          break;
          }
-       if (s < 10 || s <= bracount)
+       if (s < 8 || s <= bracount)  /* Check for back reference */
          {
          escape = -s;
          break;
-Line 1016 
 else
+Line 1231 
 else
        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 1042 
 else
+Line 1255 
 else
  #endif
      break;
-     /* \x is complicated. \x{ddd} is a character number which can be greater
+     /* \o is a relatively new Perl feature, supporting a more general way of
-     than 0xff in utf or non-8bit mode, but only if the ddd are hex digits.
+     specifying character codes in octal. The only supported form is \o{ddd}. */
-     If not, { is treated as a data character. */
+     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. In JavaScript, \x must be followed by two hexadecimal
+     numbers. Otherwise it is a lowercase x letter. */
      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)
          {
-Line 1067 
 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
-       overflow = FALSE;
+       {
-       while (MAX_255(*pt) && (digitab[*pt] & ctype_xdigit) != 0)
+       if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
          {
-         register pcre_uint32 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; }
+           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
  #if defined COMPILE_PCRE8
-         if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }
+           if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }
  #elif defined COMPILE_PCRE16
-         if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }
+           if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }
  #elif defined COMPILE_PCRE32
-         if (utf && c > 0x10ffffU) { overflow = TRUE; break; }
+           if (utf && c > 0x10ffffU) { overflow = TRUE; break; }
  #endif
-         }
+           }
-       if (overflow)
+         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
-       pcre_uint32 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 1199 
 if ((options & PCRE_UCP) != 0 && escape
+Line 1466 
 if ((options & PCRE_UCP) != 0 && escape
  return escape;
  }
  #ifdef SUPPORT_UCP
  /*************************************************
  *               Handle \P and \p                 *
-Line 1296 
 return FALSE;
+Line 1565 
 return FALSE;
  /*************************************************
  *         Read repeat counts                     *
  *************************************************/
-Line 1322 
 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 + (int)(*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 + (int)(*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 1354 
 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 1403 
 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 1419 
 for (;;)
+Line 1684 
 for (;;)
  /*************************************************
  *        Find the fixed length of a branch       *
  *************************************************/
-Line 1543 
 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 1644 
 for (;;)
+Line 1908 
 for (;;)
      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 += (int)GET2(cc,1);
        cc += 1 + 2 * IMM2_SIZE;
-Line 1760 
 for (;;)
+Line 2028 
 for (;;)
  /*************************************************
  *    Scan compiled regex for specific bracket    *
  *************************************************/
-Line 1862 
 for (;;)
+Line 2129 
 for (;;)
        {
        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 2107 
 for (code = first_significant_code(code
+Line 2402 
 for (code = first_significant_code(code
    if (c == OP_RECURSE)
      {
      const pcre_uchar *scode = cd->start_code + GET(code, 1);
+     const pcre_uchar *endgroup = scode;
      BOOL empty_branch;
      /* Test for forward reference or uncompleted reference. This is disabled
-Line 2121 
 for (code = first_significant_code(code
+Line 2417 
 for (code = first_significant_code(code
        if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
        }
-     /* If we are scanning a completed pattern, there are no forward references
+     /* If the reference is to a completed group, we need to detect whether this
-     and all groups are complete. We need to detect whether this is a recursive
+     is a recursive call, as otherwise there will be an infinite loop. If it is
-     call, as otherwise there will be an infinite loop. If it is a recursion,
+     a recursion, just skip over it. Simple recursions are easily detected. For
-     just skip over it. Simple recursions are easily detected. For mutual
+     mutual recursions we keep a chain on the stack. */
-     recursions we keep a chain on the stack. */
+     do endgroup += GET(endgroup, 1); while (*endgroup == OP_ALT);
+     if (code >= scode && code <= endgroup) continue;  /* Simple recursion */
      else
        {
        recurse_check *r = recurses;
-       const pcre_uchar *endgroup = scode;
-       do endgroup += GET(endgroup, 1); while (*endgroup == OP_ALT);
-       if (code >= scode && code <= endgroup) continue;  /* Simple recursion */
        for (r = recurses; r != NULL; r = r->prev)
          if (r->group == scode) break;
        if (r != NULL) continue;   /* Mutual recursion */
-Line 2205 
 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, NULL))
+         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 2247 
 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 2462 
 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
- 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 that 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
+ Arguments:  c opcode
+ Returns:    base opcode for the type
  */
- static BOOL
+ static pcre_uchar
- check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr)
+ get_repeat_base(pcre_uchar c)
  {
- pcre_uchar terminator;          /* Don't combine these lines; the Solaris cc */
+ return (c > OP_TYPEPOSUPTO)? c :
- terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
+        (c >= OP_TYPESTAR)?   OP_TYPESTAR :
- for (++ptr; *ptr != CHAR_NULL; ptr++)
+        (c >= OP_NOTSTARI)?   OP_NOTSTARI :
-   {
+        (c >= OP_NOTSTAR)?    OP_NOTSTAR :
-   if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
+        (c >= OP_STARI)?      OP_STARI :
-     ptr++;
+                              OP_STAR;
-   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;
  }
+ #ifdef SUPPORT_UCP
  /*************************************************
- *          Check POSIX class name                *
+ *        Check a character and a property        *
  *************************************************/
- /* This function is called to check the name given in a POSIX-style class entry
+ /* This function is called by check_auto_possessive() when a property item
- such as [:alnum:].
+ is adjacent to a fixed character.
  Arguments:
-   ptr        points to the first letter
+   c            the character
-   len        the length of the name
+   ptype        the property type
+   pdata        the data for the type
+   negated      TRUE if it's a negated property (\P or \p{^)
- Returns:     a value representing the name, or -1 if unknown
+ Returns:       TRUE if auto-possessifying is OK
  */
- static int
+ static BOOL
- check_posix_name(const pcre_uchar *ptr, int len)
+ check_char_prop(pcre_uint32 c, unsigned int ptype, unsigned int pdata,
+   BOOL negated)
  {
- const char *pn = posix_names;
+ const pcre_uint32 *p;
- register int yield = 0;
+ const ucd_record *prop = GET_UCD(c);
- while (posix_name_lengths[yield] != 0)
+ switch(ptype)
    {
-   if (len == posix_name_lengths[yield] &&
+   case PT_LAMP:
-     STRNCMP_UC_C8(ptr, pn, (unsigned int)len) == 0) return yield;
+   return (prop->chartype == ucp_Lu ||
-   pn += posix_name_lengths[yield] + 1;
+           prop->chartype == ucp_Ll ||
-   yield++;
+           prop->chartype == ucp_Lt) == negated;
-   }
- return -1;
- }
+   case PT_GC:
+   return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;
- /*************************************************
+   case PT_PC:
- *    Adjust OP_RECURSE items in repeated group   *
+   return (pdata == prop->chartype) == negated;
- *************************************************/
- /* OP_RECURSE items contain an offset from the start of the regex to the group
+   case PT_SC:
- that is referenced. This means that groups can be replicated for fixed
+   return (pdata == prop->script) == negated;
- 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   the hwm forward reference pointer at the start of the group
- Returns:     nothing
- */
- static void
+   /* These are specials */
- adjust_recurse(pcre_uchar *group, int adjust, BOOL utf, compile_data *cd,
-   pcre_uchar *save_hwm)
- {
- pcre_uchar *ptr = group;
- while ((ptr = (pcre_uchar *)find_recurse(ptr, utf)) != NULL)
+   case PT_ALNUM:
-   {
+   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
-   int offset;
+           PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;
-   pcre_uchar *hc;
-   /* See if this recursion is on the forward reference list. If so, adjust the
+   /* Perl space used to exclude VT, but from Perl 5.18 it is included, which
-   reference. */
+   means that Perl space and POSIX space are now identical. PCRE was changed
+   at release 8.34. */
-   for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)
+   case PT_SPACE:    /* Perl space */
+   case PT_PXSPACE:  /* POSIX space */
+   switch(c)
      {
-     offset = (int)GET(hc, 0);
+     HSPACE_CASES:
-     if (cd->start_code + offset == ptr + 1)
+     VSPACE_CASES:
-       {
+     return negated;
-       PUT(hc, 0, offset + adjust);
-       break;
+     default:
-       }
+     return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == negated;
      }
+   break;  /* Control never reaches here */
-   /* Otherwise, adjust the recursion offset if it's after the start of this
+   case PT_WORD:
-   group. */
+   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+           PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
+           c == CHAR_UNDERSCORE) == negated;
-   if (hc >= cd->hwm)
+   case PT_CLIST:
+   p = PRIV(ucd_caseless_sets) + prop->caseset;
+   for (;;)
      {
-     offset = (int)GET(ptr, 1);
+     if (c < *p) return !negated;
-     if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
+     if (c == *p++) return negated;
      }
+   break;  /* Control never reaches here */
-   ptr += 1 + LINK_SIZE;
    }
+ return FALSE;
  }
+ #endif  /* SUPPORT_UCP */
  /*************************************************
- *        Insert an automatic callout point       *
+ *        Fill the character property list        *
  *************************************************/
- /* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert
+ /* Checks whether the code points to an opcode that can take part in auto-
- callout points before each pattern item.
+ possessification, and if so, fills a list with its properties.
  Arguments:
-   code           current code pointer
+   code        points to start of expression
-   ptr            current pattern pointer
+   utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
-   cd             pointers to tables etc
+   fcc         points to case-flipping table
+   list        points to output list
+               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:         new code pointer
+ Returns:      points to the start of the next opcode if *code is accepted
+               NULL if *code is not accepted
  */
- static pcre_uchar *
+ static const pcre_uchar *
- auto_callout(pcre_uchar *code, const pcre_uchar *ptr, compile_data *cd)
+ get_chr_property_list(const pcre_uchar *code, BOOL utf,
+   const pcre_uint8 *fcc, pcre_uint32 *list)
  {
- *code++ = OP_CALLOUT;
+ pcre_uchar c = *code;
- *code++ = 255;
+ pcre_uchar base;
- PUT(code, 0, (int)(ptr - cd->start_pattern));  /* Pattern offset */
+ const pcre_uchar *end;
- PUT(code, LINK_SIZE, 0);                       /* Default length */
+ pcre_uint32 chr;
- return code + 2 * LINK_SIZE;
- }
+ #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)
- *         Complete a callout item                *
+   {
- *************************************************/
+   base = get_repeat_base(c);
+   c -= (base - OP_STAR);
- /* A callout item contains the length of the next item in the pattern, which
+   if (c == OP_UPTO || c == OP_MINUPTO || c == OP_EXACT || c == OP_POSUPTO)
- we can't fill in till after we have reached the relevant point. This is used
+     code += IMM2_SIZE;
- for both automatic and manual callouts.
- Arguments:
+   list[1] = (c != OP_PLUS && c != OP_MINPLUS && c != OP_EXACT && c != OP_POSPLUS);
-   previous_callout   points to previous callout item
-   ptr                current pattern pointer
-   cd                 pointers to tables etc
- Returns:             nothing
+   switch(base)
- */
+     {
+     case OP_STAR:
+     list[0] = OP_CHAR;
+     break;
- static void
+     case OP_STARI:
- complete_callout(pcre_uchar *previous_callout, const pcre_uchar *ptr, compile_data *cd)
+     list[0] = OP_CHARI;
- {
+     break;
- int length = (int)(ptr - cd->start_pattern - GET(previous_callout, 2));
- PUT(previous_callout, 2 + LINK_SIZE, length);
- }
+     case OP_NOTSTAR:
+     list[0] = OP_NOT;
+     break;
+     case OP_NOTSTARI:
+     list[0] = OP_NOTI;
+     break;
- #ifdef SUPPORT_UCP
+     case OP_TYPESTAR:
- /*************************************************
+     list[0] = *code;
- *           Get othercase range                  *
+     code++;
- *************************************************/
+     break;
+     }
+   c = list[0];
+   }
- /* This function is passed the start and end of a class range, in UTF-8 mode
+ switch(c)
- 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
+   case OP_NOT_DIGIT:
- start address. A character with multiple other cases is returned on its own
+   case OP_DIGIT:
- with a special return value.
+   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;
- Arguments:
+   case OP_CHAR:
-   cptr        points to starting character value; updated
+   case OP_NOT:
-   d           end value
+   GETCHARINCTEST(chr, code);
-   ocptr       where to put start of othercase range
+   list[2] = chr;
-   odptr       where to put end of othercase range
+   list[3] = NOTACHAR;
+   return code;
- Yield:        -1 when no more
+   case OP_CHARI:
-when a range is returned
+   case OP_NOTI:
-               >0 the CASESET offset for char with multiple other cases
+   list[0] = (c == OP_CHARI) ? OP_CHAR : OP_NOT;
-                 in this case, ocptr contains the original
+   GETCHARINCTEST(chr, code);
- */
+   list[2] = chr;
- static int
+ #ifdef SUPPORT_UCP
- get_othercase_range(pcre_uint32 *cptr, pcre_uint32 d, pcre_uint32 *ocptr,
+   if (chr < 128 || (chr < 256 && !utf))
-   pcre_uint32 *odptr)
+     list[3] = fcc[chr];
- {
+   else
- pcre_uint32 c, othercase, next;
+     list[3] = UCD_OTHERCASE(chr);
- unsigned int co;
+ #elif defined SUPPORT_UTF || !defined COMPILE_PCRE8
+   list[3] = (chr < 256) ? fcc[chr] : chr;
+ #else
+   list[3] = fcc[chr];
+ #endif
- /* Find the first character that has an other case. If it has multiple other
+   /* The othercase might be the same value. */
- cases, return its case offset value. */
- for (c = *cptr; c <= d; c++)
+   if (chr == list[3])
-   {
+     list[3] = NOTACHAR;
-   if ((co = UCD_CASESET(c)) != 0)
+   else
+     list[4] = NOTACHAR;
+   return code;
+ #ifdef SUPPORT_UCP
+   case OP_PROP:
+   case OP_NOTPROP:
+   if (code[0] != PT_CLIST)
      {
-     *ocptr = c++;   /* Character that has the set */
+     list[2] = code[0];
-     *cptr = c;      /* Rest of input range */
+     list[3] = code[1];
-     return (int)co;
+     return code + 2;
      }
-   if ((othercase = UCD_OTHERCASE(c)) != c) break;
-   }
- if (c > d) return -1;  /* Reached end of range */
+   /* Convert only if we have enough space. */
- *ocptr = othercase;
+   clist_src = PRIV(ucd_caseless_sets) + code[1];
- next = othercase + 1;
+   clist_dest = list + 2;
+   code += 2;
- for (++c; c <= d; c++)
+   do {
-   {
+      if (clist_dest >= list + 8)
-   if (UCD_OTHERCASE(c) != next) break;
+        {
-   next++;
+        /* 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);
- *odptr = next - 1;     /* End of othercase range */
+   /* All characters are stored. The terminating NOTACHAR
- *cptr = c;             /* Rest of input range */
+   is copied form the clist itself. */
- return 0;
+   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 */
  }
  /*************************************************
- *        Check a character and a property        *
+ *    Scan further character sets for match       *
  *************************************************/
- /* This function is called by check_auto_possessive() when a property item
+ /* Checks whether the base and the current opcode have a common character, in
- is adjacent to a fixed character.
+ which case the base cannot be possessified.
  Arguments:
-   c            the character
+   code        points to the byte code
-   ptype        the property type
+   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
-   pdata        the data for the type
+   cd          static compile data
-   negated      TRUE if it's a negated property (\P or \p{^)
+   base_list   the data list of the base opcode
- Returns:       TRUE if auto-possessifying is OK
+ Returns:      TRUE if the auto-possessification is possible
  */
  static BOOL
- check_char_prop(pcre_uint32 c, unsigned int ptype, unsigned int pdata, BOOL negated)
+ 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)
  {
- #ifdef SUPPORT_UCP
+ pcre_uchar c;
- const pcre_uint32 *p;
+ 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). */
- const ucd_record *prop = GET_UCD(c);
+ for(;;)
- switch(ptype)
    {
-   case PT_LAMP:
+   /* All operations move the code pointer forward.
-   return (prop->chartype == ucp_Lu ||
+   Therefore infinite recursions are not possible. */
-           prop->chartype == ucp_Ll ||
-           prop->chartype == ucp_Lt) == negated;
-   case PT_GC:
+   c = *code;
-   return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;
-   case PT_PC:
+   /* Skip over callouts */
-   return (pdata == prop->chartype) == negated;
-   case PT_SC:
+   if (c == OP_CALLOUT)
-   return (pdata == prop->script) == negated;
+     {
+     code += PRIV(OP_lengths)[c];
+     continue;
+     }
-   /* These are specials */
+   if (c == OP_ALT)
+     {
+     do code += GET(code, 1); while (*code == OP_ALT);
+     c = *code;
+     }
-   case PT_ALNUM:
+   switch(c)
-   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+     {
-           PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;
+     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.) */
-   case PT_SPACE:    /* Perl space */
+     return base_list[1] != 0;
-   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 */
+     case OP_KET:
-   return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
+     /* If the bracket is capturing, and referenced by an OP_RECURSE, or
-           c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
+     it is an atomic sub-pattern (assert, once, etc.) the non-greedy case
-           c == CHAR_FF || c == CHAR_CR)
+     cannot be converted to a possessive form. */
-           == negated;
+     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. */
-   case PT_WORD:
+       return !entered_a_group;
-   return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+       }
-           PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
-           c == CHAR_UNDERSCORE) == negated;
- #ifdef SUPPORT_UCP
+     code += PRIV(OP_lengths)[c];
-   case PT_CLIST:
+     continue;
-   p = PRIV(ucd_caseless_sets) + prop->caseset;
-   for (;;)
+     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)
      {
-     if (c < *p) return !negated;
+     chr_ptr = base_list + 2;
-     if (c == *p++) return negated;
+     list_ptr = list;
      }
-   break;  /* Control never reaches here */
+   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;
    }
- return FALSE;
+ /* Control never reaches here. There used to be a fail-save return FALSE; here,
+ but some compilers complain about an unreachable statement. */
  }
- #endif  /* SUPPORT_UCP */
  /*************************************************
- *     Check if auto-possessifying is possible    *
+ *    Scan compiled regex for auto-possession     *
  *************************************************/
- /* This function is called for unlimited repeats of certain items, to see
+ /* Replaces single character iterations with their possessive alternatives
- whether the next thing could possibly match the repeated item. If not, it makes
+ if appropriate. This function modifies the compiled opcode!
- sense to automatically possessify the repeated item.
  Arguments:
-   previous      pointer to the repeated opcode
+   code        points to start of the byte code
-   utf           TRUE in UTF-8 / UTF-16 / UTF-32 mode
+   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
-   ptr           next character in pattern
+   cd          static compile data
-   options       options bits
-   cd            contains pointers to tables etc.
- Returns:        TRUE if possessifying is wanted
+ Returns:      nothing
  */
- static BOOL
+ static void
- check_auto_possessive(const pcre_uchar *previous, BOOL utf,
+ auto_possessify(pcre_uchar *code, BOOL utf, const compile_data *cd)
-   const pcre_uchar *ptr, int options, compile_data *cd)
  {
- pcre_uint32 c = NOTACHAR;
+ register pcre_uchar c;
- pcre_uint32 next;
+ const pcre_uchar *end;
- int escape;
+ pcre_uchar *repeat_opcode;
- pcre_uchar op_code = *previous++;
+ pcre_uint32 list[8];
+ int rec_limit;
- /* Skip whitespace and comments in extended mode */
- if ((options & PCRE_EXTENDED) != 0)
+ for (;;)
    {
-   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)
      {
-     while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
+     c -= get_repeat_base(c) - OP_STAR;
-     if (*ptr == CHAR_NUMBER_SIGN)
+     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))
        {
-       ptr++;
+       switch(c)
-       while (*ptr != CHAR_NULL)
          {
-         if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
+         case OP_STAR:
-         ptr++;
+         *code += OP_POSSTAR - OP_STAR;
- #ifdef SUPPORT_UTF
+         break;
-         if (utf) FORWARDCHAR(ptr);
- #endif
-         }
-       }
-     else break;
-     }
-   }
- /* If the next item is one that we can handle, get its value. A non-negative
+         case OP_MINSTAR:
- value is a character, a negative value is an escape value. */
+         *code += OP_POSSTAR - OP_MINSTAR;
+         break;
- if (*ptr == CHAR_BACKSLASH)
+         case OP_PLUS:
-   {
+         *code += OP_POSPLUS - OP_PLUS;
-   int temperrorcode = 0;
+         break;
-   escape = check_escape(&ptr, &next, &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)
-   {
-   escape = 0;
- #ifdef SUPPORT_UTF
-   if (utf) { GETCHARINC(next, ptr); } else
- #endif
-   next = *ptr++;
-   }
- else return FALSE;
- /* Skip whitespace and comments in extended mode */
+         case OP_MINPLUS:
+         *code += OP_POSPLUS - OP_MINPLUS;
+         break;
- if ((options & PCRE_EXTENDED) != 0)
+         case OP_QUERY:
-   {
+         *code += OP_POSQUERY - OP_QUERY;
-   for (;;)
+         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)
      {
-     while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
-     if (*ptr == CHAR_NUMBER_SIGN)
+     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)
        {
-       ptr++;
+       /* end must not be NULL. */
-       while (*ptr != CHAR_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))
          {
-         if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
+         switch (c)
-         ptr++;
+           {
- #ifdef SUPPORT_UTF
+           case OP_CRSTAR:
-         if (utf) FORWARDCHAR(ptr);
+           case OP_CRMINSTAR:
- #endif
+           *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;
+           }
          }
        }
-     else break;
+     c = *code;
      }
-   }
- /* If the next thing is itself optional, we have to give up. */
+   switch(c)
+     {
+     case OP_END:
+     return;
- if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||
+     case OP_TYPESTAR:
-   STRNCMP_UC_C8(ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
+     case OP_TYPEMINSTAR:
-     return FALSE;
+     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;
- /* If the previous item is a character, get its value. */
+     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 (op_code == OP_CHAR || op_code == OP_CHARI ||
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
-     op_code == OP_NOT || op_code == OP_NOTI)
+     case OP_XCLASS:
-   {
+     code += GET(code, 1);
- #ifdef SUPPORT_UTF
+     break;
-   GETCHARTEST(c, previous);
- #else
-   c = *previous;
  #endif
-   }
- /* Now compare the next item with the previous opcode. First, handle cases when
+     case OP_MARK:
- the next item is a character. */
+     case OP_PRUNE_ARG:
+     case OP_SKIP_ARG:
+     case OP_THEN_ARG:
+     code += code[1];
+     break;
+     }
- if (escape == 0)
+   /* Add in the fixed length from the table */
-   {
-   /* For a caseless UTF match, the next character may have more than one other
-   case, which maps to the special PT_CLIST property. Check this first. */
- #ifdef SUPPORT_UCP
+   code += PRIV(OP_lengths)[c];
-   if (utf && c != NOTACHAR && (options & PCRE_CASELESS) != 0)
-     {
-     unsigned int ocs = UCD_CASESET(next);
-     if (ocs > 0) return check_char_prop(c, PT_CLIST, ocs, op_code >= OP_NOT);
-     }
- #endif
-   switch(op_code)
+   /* 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:
-     return c != next;
-     /* For CHARI (caseless character) we must check the other case. If we have
-     Unicode property support, we can use it to test the other case of
-     high-valued characters. We know that next can have only one other case,
-     because multi-other-case characters are dealt with above. */
      case OP_CHARI:
-     if (c == next) return FALSE;
+     case OP_NOT:
- #ifdef SUPPORT_UTF
+     case OP_NOTI:
-     if (utf)
+     case OP_STAR:
-       {
+     case OP_MINSTAR:
-       pcre_uint32 othercase;
+     case OP_PLUS:
-       if (next < 128) othercase = cd->fcc[next]; else
+     case OP_MINPLUS:
- #ifdef SUPPORT_UCP
+     case OP_QUERY:
-       othercase = UCD_OTHERCASE(next);
+     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
-       othercase = NOTACHAR;
+   (void)(utf);  /* Keep compiler happy by referencing function argument */
  #endif
-       return c != othercase;
+   }
-       }
+ }
-     else
- #endif  /* SUPPORT_UTF */
-     return (c != TABLE_GET(next, cd->fcc, next));  /* Not UTF */
-     case OP_NOT:
-     return c == next;
-     case OP_NOTI:
-     if (c == next) return TRUE;
+ /*************************************************
- #ifdef SUPPORT_UTF
+ *           Check for POSIX class syntax         *
-     if (utf)
+ *************************************************/
+ /* 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)
        {
-       pcre_uint32 othercase;
+       *endptr = ptr;
-       if (next < 128) othercase = cd->fcc[next]; else
+       return TRUE;
- #ifdef SUPPORT_UCP
-       othercase = UCD_OTHERCASE(next);
- #else
-       othercase = NOTACHAR;
- #endif
-       return c == othercase;
        }
-     else
+     if (*ptr == CHAR_LEFT_SQUARE_BRACKET &&
- #endif  /* SUPPORT_UTF */
+          (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
-     return (c == TABLE_GET(next, cd->fcc, next));  /* Not UTF */
+           ptr[1] == CHAR_EQUALS_SIGN) &&
+         check_posix_syntax(ptr, endptr))
+       return FALSE;
+     }
+   }
+ return FALSE;
+ }
-     /* 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:
-     return next > 255 || (cd->ctypes[next] & ctype_digit) == 0;
-     case OP_NOT_DIGIT:
-     return next <= 255 && (cd->ctypes[next] & ctype_digit) != 0;
-     case OP_WHITESPACE:
+ /*************************************************
-     return next > 255 || (cd->ctypes[next] & ctype_space) == 0;
+ *          Check POSIX class name                *
+ *************************************************/
-     case OP_NOT_WHITESPACE:
+ /* This function is called to check the name given in a POSIX-style class entry
-     return next <= 255 && (cd->ctypes[next] & ctype_space) != 0;
+ such as [:alnum:].
-     case OP_WORDCHAR:
+ Arguments:
-     return next > 255 || (cd->ctypes[next] & ctype_word) == 0;
+   ptr        points to the first letter
+   len        the length of the name
-     case OP_NOT_WORDCHAR:
+ Returns:     a value representing the name, or -1 if unknown
-     return next <= 255 && (cd->ctypes[next] & ctype_word) != 0;
+ */
-     case OP_HSPACE:
+ static int
-     case OP_NOT_HSPACE:
+ check_posix_name(const pcre_uchar *ptr, int len)
-     switch(next)
+ {
-       {
+ const char *pn = posix_names;
-       HSPACE_CASES:
+ register int yield = 0;
-       return op_code == OP_NOT_HSPACE;
+ 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;
+ }
-       default:
-       return op_code != OP_NOT_HSPACE;
-       }
-     case OP_ANYNL:
+ /*************************************************
-     case OP_VSPACE:
+ *    Adjust OP_RECURSE items in repeated group   *
-     case OP_NOT_VSPACE:
+ *************************************************/
-     switch(next)
-       {
-       VSPACE_CASES:
-       return op_code == OP_NOT_VSPACE;
-       default:
+ /* OP_RECURSE items contain an offset from the start of the regex to the group
-       return op_code != OP_NOT_VSPACE;
+ 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.
- #ifdef SUPPORT_UCP
+ This function has been extended with the possibility of forward references for
-     case OP_PROP:
+ recursions and subroutine calls. It must also check the list of such references
-     return check_char_prop(next, previous[0], previous[1], FALSE);
+ 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).
-     case OP_NOTPROP:
+ Arguments:
-     return check_char_prop(next, previous[0], previous[1], TRUE);
+   group      points to the start of the group
- #endif
+   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
-     default:
+ Returns:     nothing
-     return FALSE;
+ */
-     }
-   }
- /* Handle the case when the next item is \d, \s, etc. Note that when PCRE_UCP
+ static void
- is set, \d turns into ESC_du rather than ESC_d, etc., so ESC_d etc. are
+ adjust_recurse(pcre_uchar *group, int adjust, BOOL utf, compile_data *cd,
- generated only when PCRE_UCP is *not* set, that is, when only ASCII
+   size_t save_hwm_offset)
- characteristics are recognized. Similarly, the opcodes OP_DIGIT etc. are
+ {
- replaced by OP_PROP codes when PCRE_UCP is set. */
+ pcre_uchar *ptr = group;
- switch(op_code)
+ while ((ptr = (pcre_uchar *)find_recurse(ptr, utf)) != NULL)
    {
-   case OP_CHAR:
+   int offset;
-   case OP_CHARI:
+   pcre_uchar *hc;
-   switch(escape)
+   /* 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)
      {
-     case ESC_d:
+     offset = (int)GET(hc, 0);
-     return c > 255 || (cd->ctypes[c] & ctype_digit) == 0;
+     if (cd->start_code + offset == ptr + 1)
+       {
+       PUT(hc, 0, offset + adjust);
+       break;
+       }
+     }
-     case ESC_D:
+   /* Otherwise, adjust the recursion offset if it's after the start of this
-     return c <= 255 && (cd->ctypes[c] & ctype_digit) != 0;
+   group. */
-     case ESC_s:
+   if (hc >= cd->hwm)
-     return c > 255 || (cd->ctypes[c] & ctype_space) == 0;
+     {
+     offset = (int)GET(ptr, 1);
+     if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
+     }
-     case ESC_S:
+   ptr += 1 + LINK_SIZE;
-     return c <= 255 && (cd->ctypes[c] & ctype_space) != 0;
+   }
+ }
-     case ESC_w:
-     return c > 255 || (cd->ctypes[c] & ctype_word) == 0;
-     case ESC_W:
-     return c <= 255 && (cd->ctypes[c] & ctype_word) != 0;
-     case ESC_h:
+ /*************************************************
-     case ESC_H:
+ *        Insert an automatic callout point       *
-     switch(c)
+ *************************************************/
-       {
-       HSPACE_CASES:
-       return escape != ESC_h;
-       default:
+ /* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert
-       return escape == ESC_h;
+ callout points before each pattern item.
-       }
-     case ESC_v:
+ Arguments:
-     case ESC_V:
+   code           current code pointer
-     switch(c)
+   ptr            current pattern pointer
-       {
+   cd             pointers to tables etc
-       VSPACE_CASES:
-       return escape != ESC_v;
-       default:
+ Returns:         new code pointer
-       return escape == ESC_v;
+ */
-       }
-     /* When PCRE_UCP is set, these values get generated for \d etc. Find
+ static pcre_uchar *
-     their substitutions and process them. The result will always be either
+ auto_callout(pcre_uchar *code, const pcre_uchar *ptr, compile_data *cd)
-     ESC_p or ESC_P. Then fall through to process those values. */
+ {
+ *code++ = OP_CALLOUT;
+ *code++ = 255;
+ PUT(code, 0, (int)(ptr - cd->start_pattern));  /* Pattern offset */
+ PUT(code, LINK_SIZE, 0);                       /* Default length */
+ return code + 2 * LINK_SIZE;
+ }
- #ifdef SUPPORT_UCP
-     case ESC_du:
-     case ESC_DU:
-     case ESC_wu:
-     case ESC_WU:
-     case ESC_su:
-     case ESC_SU:
-       {
-       int temperrorcode = 0;
-       ptr = substitutes[escape - ESC_DU];
-       escape = check_escape(&ptr, &next, &temperrorcode, 0, options, FALSE);
-       if (temperrorcode != 0) return FALSE;
-       ptr++;    /* For compatibility */
-       }
-     /* Fall through */
-     case ESC_p:
-     case ESC_P:
-       {
-       unsigned int ptype = 0, pdata = 0;
-       int errorcodeptr;
-       BOOL negated;
-       ptr--;      /* Make ptr point at the p or P */
+ /*************************************************
-       if (!get_ucp(&ptr, &negated, &ptype, &pdata, &errorcodeptr))
+ *         Complete a callout item                *
-         return FALSE;
+ *************************************************/
-       ptr++;      /* Point past the final curly ket */
-       /* If the property item is optional, we have to give up. (When generated
+ /* A callout item contains the length of the next item in the pattern, which
-       from \d etc by PCRE_UCP, this test will have been applied much earlier,
+ we can't fill in till after we have reached the relevant point. This is used
-       to the original \d etc. At this point, ptr will point to a zero byte. */
+ for both automatic and manual callouts.
-       if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||
+ Arguments:
-         STRNCMP_UC_C8(ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
+   previous_callout   points to previous callout item
-           return FALSE;
+   ptr                current pattern pointer
+   cd                 pointers to tables etc
-       /* Do the property check. */
+ Returns:             nothing
+ */
-       return check_char_prop(c, ptype, pdata, (escape == ESC_P) != negated);
+ static void
-       }
+ complete_callout(pcre_uchar *previous_callout, const pcre_uchar *ptr, compile_data *cd)
- #endif
+ {
+ int length = (int)(ptr - cd->start_pattern - GET(previous_callout, 2));
+ PUT(previous_callout, 2 + LINK_SIZE, length);
+ }
-     default:
-     return FALSE;
-     }
-   /* In principle, support for Unicode properties should be integrated here as
-   well. It means re-organizing the above code so as to get hold of the property
-   values before switching on the op-code. However, I wonder how many patterns
-   combine ASCII \d etc with Unicode properties? (Note that if PCRE_UCP is set,
-   these op-codes are never generated.) */
-   case OP_DIGIT:
+ #ifdef SUPPORT_UCP
-   return escape == ESC_D || escape == ESC_s || escape == ESC_W ||
+ /*************************************************
-          escape == ESC_h || escape == ESC_v || escape == ESC_R;
+ *           Get othercase range                  *
+ *************************************************/
-   case OP_NOT_DIGIT:
+ /* This function is passed the start and end of a class range, in UTF-8 mode
-   return escape == ESC_d;
+ 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. A character with multiple other cases is returned on its own
+ with a special return value.
-   case OP_WHITESPACE:
+ Arguments:
-   return escape == ESC_S || escape == ESC_d || escape == ESC_w;
+   cptr        points to starting character value; updated
+   d           end value
+   ocptr       where to put start of othercase range
+   odptr       where to put end of othercase range
-   case OP_NOT_WHITESPACE:
+ Yield:        -1 when no more
-   return escape == ESC_s || escape == ESC_h || escape == ESC_v || escape == ESC_R;
+when a range is returned
+               >0 the CASESET offset for char with multiple other cases
+                 in this case, ocptr contains the original
+ */
-   case OP_HSPACE:
+ static int
-   return escape == ESC_S || escape == ESC_H || escape == ESC_d ||
+ get_othercase_range(pcre_uint32 *cptr, pcre_uint32 d, pcre_uint32 *ocptr,
-          escape == ESC_w || escape == ESC_v || escape == ESC_R;
+   pcre_uint32 *odptr)
+ {
+ pcre_uint32 c, othercase, next;
+ unsigned int co;
-   case OP_NOT_HSPACE:
+ /* Find the first character that has an other case. If it has multiple other
-   return escape == ESC_h;
+ cases, return its case offset value. */
-   /* Can't have \S in here because VT matches \S (Perl anomaly) */
+ for (c = *cptr; c <= d; c++)
-   case OP_ANYNL:
+   {
-   case OP_VSPACE:
+   if ((co = UCD_CASESET(c)) != 0)
-   return escape == ESC_V || escape == ESC_d || escape == ESC_w;
+     {
+     *ocptr = c++;   /* Character that has the set */
+     *cptr = c;      /* Rest of input range */
+     return (int)co;
+     }
+   if ((othercase = UCD_OTHERCASE(c)) != c) break;
+   }
-   case OP_NOT_VSPACE:
+ if (c > d) return -1;  /* Reached end of range */
-   return escape == ESC_v || escape == ESC_R;
-   case OP_WORDCHAR:
+ /* Found a character that has a single other case. Search for the end of the
-   return escape == ESC_W || escape == ESC_s || escape == ESC_h ||
+ range, which is either the end of the input range, or a character that has zero
-          escape == ESC_v || escape == ESC_R;
+ or more than one other cases. */
-   case OP_NOT_WORDCHAR:
+ *ocptr = othercase;
-   return escape == ESC_w || escape == ESC_d;
+ next = othercase + 1;
-   default:
+ for (++c; c <= d; c++)
-   return FALSE;
+   {
+   if ((co = UCD_CASESET(c)) != 0 || UCD_OTHERCASE(c) != next) break;
+   next++;
    }
- /* Control does not reach here */
+ *odptr = next - 1;     /* End of othercase range */
+ *cptr = c;             /* Rest of input range */
+ return 0;
  }
+ #endif  /* SUPPORT_UCP */
-Line 3240 
 add_to_class(pcre_uint8 *classbits, pcre
+Line 4180 
 add_to_class(pcre_uint8 *classbits, pcre
    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
-Line 3274 
 if ((options & PCRE_CASELESS) != 0)
+Line 4215 
 if ((options & PCRE_CASELESS) != 0)
        range. Otherwise, use a recursive call to add the additional range. */
        else if (oc < start && od >= start - 1) start = oc; /* Extend downwards */
-       else if (od > end && oc <= end + 1) end = od;       /* Extend upwards */
+       else if (od > end && oc <= end + 1)
+         {
+         end = od;       /* Extend upwards */
+         if (end > classbits_end) classbits_end = (end <= 0xff ? end : 0xff);
+         }
        else n8 += add_to_class(classbits, uchardptr, options, cd, oc, od);
        }
      }
-Line 3283 
 if ((options & PCRE_CASELESS) != 0)
+Line 4228 
 if ((options & PCRE_CASELESS) != 0)
    /* Not UTF-mode, or no UCP */
-   for (c = start; c <= end && c < 256; c++)
+   for (c = start; c <= classbits_end; c++)
      {
      SETBIT(classbits, cd->fcc[c]);
      n8++;
-Line 3308 
 in all cases. */
+Line 4253 
 in all cases. */
  #endif /* COMPILE_PCRE[8|16] */
- /* If all characters are less than 256, use the bit map. Otherwise use extra
+ /* Use the bitmap for characters < 256. Otherwise use extra data.*/
- data. */
- if (end < 0x100)
+ for (c = start; c <= classbits_end; c++)
    {
-   for (c = start; c <= end; c++)
+   /* Regardless of start, c will always be <= 255. */
-     {
+   SETBIT(classbits, c);
-     n8++;
+   n8++;
-     SETBIT(classbits, c);
-     }
    }
- else
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+ if (start <= 0xff) start = 0xff + 1;
+ if (end >= start)
    {
    pcre_uchar *uchardata = *uchardptr;
  #ifdef SUPPORT_UTF
    if ((options & PCRE_UTF8) != 0)  /* All UTFs use the same flag bit */
      {
-Line 3363 
 else
+Line 4307 
 else
    *uchardptr = uchardata;   /* Updata extra data pointer */
    }
+ #endif /* SUPPORT_UTF || !COMPILE_PCRE8 */
  return n8;    /* Number of 8-bit characters */
  }
-Line 3514 
 const pcre_uchar *tempptr;
+Line 4459 
 const pcre_uchar *tempptr;
  const pcre_uchar *nestptr = NULL;
  pcre_uchar *previous = NULL;
  pcre_uchar *previous_callout = NULL;
- pcre_uchar *save_hwm = NULL;
+ size_t save_hwm_offset = 0;
  pcre_uint8 classbits[32];
  /* We can fish out the UTF-8 setting once and for all into a BOOL, but we
-Line 3584 
 for (;; ptr++)
+Line 4529 
 for (;; ptr++)
    BOOL reset_bracount;
    int class_has_8bitchar;
    int class_one_char;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+   BOOL xclass_has_prop;
+ #endif
    int newoptions;
    int recno;
    int refsign;
-Line 3701 
 for (;; ptr++)
+Line 4649 
 for (;; ptr++)
          }
        goto NORMAL_CHAR;
        }
+     /* Control does not reach here. */
      }
-   /* Fill in length of a previous callout, except when the next thing is
+   /* In extended mode, skip white space and comments. We need a loop in order
-   a quantifier. */
+   to check for more white space and more comments after a comment. */
-   is_quantifier =
-     c == CHAR_ASTERISK || c == CHAR_PLUS || c == CHAR_QUESTION_MARK ||
-     (c == CHAR_LEFT_CURLY_BRACKET && is_counted_repeat(ptr+1));
-   if (!is_quantifier && previous_callout != NULL &&
-        after_manual_callout-- <= 0)
-     {
-     if (lengthptr == NULL)      /* Don't attempt in pre-compile phase */
-       complete_callout(previous_callout, ptr, cd);
-     previous_callout = NULL;
-     }
-   /* In extended mode, skip white space and comments. */
    if ((options & PCRE_EXTENDED) != 0)
      {
-     if (MAX_255(*ptr) && (cd->ctypes[c] & ctype_space) != 0) continue;
+     for (;;)
-     if (c == CHAR_NUMBER_SIGN)
        {
+       while (MAX_255(c) && (cd->ctypes[c] & ctype_space) != 0) c = *(++ptr);
+       if (c != CHAR_NUMBER_SIGN) break;
        ptr++;
        while (*ptr != CHAR_NULL)
          {
-         if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }
+         if (IS_NEWLINE(ptr))         /* For non-fixed-length newline cases, */
+           {                          /* IS_NEWLINE sets cd->nllen. */
+           ptr += cd->nllen;
+           break;
+           }
          ptr++;
  #ifdef SUPPORT_UTF
          if (utf) FORWARDCHAR(ptr);
  #endif
          }
-       if (*ptr != CHAR_NULL) continue;
+       c = *ptr;     /* Either NULL or the char after a newline */
-       /* Else fall through to handle end of string */
-       c = 0;
        }
      }
-   /* No auto callout for quantifiers. */
+   /* See if the next thing is a quantifier. */
-   if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier)
+   is_quantifier =
+     c == CHAR_ASTERISK || c == CHAR_PLUS || c == CHAR_QUESTION_MARK ||
+     (c == CHAR_LEFT_CURLY_BRACKET && is_counted_repeat(ptr+1));
+   /* Fill in length of a previous callout, except when the next thing is a
+   quantifier or when processing a property substitution string in UCP mode. */
+   if (!is_quantifier && previous_callout != NULL && nestptr == NULL &&
+        after_manual_callout-- <= 0)
+     {
+     if (lengthptr == NULL)      /* Don't attempt in pre-compile phase */
+       complete_callout(previous_callout, ptr, cd);
+     previous_callout = NULL;
+     }
+   /* Create auto callout, except for quantifiers, or while processing property
+   strings that are substituted for \w etc in UCP mode. */
+   if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier && nestptr == NULL)
      {
      previous_callout = code;
      code = auto_callout(code, ptr, cd);
      }
+   /* Process the next pattern item. */
    switch(c)
      {
      /* ===================================================================*/
-     case 0:                        /* The branch terminates at string end */
+     case CHAR_NULL:                /* The branch terminates at string end */
      case CHAR_VERTICAL_LINE:       /* or | or ) */
      case CHAR_RIGHT_PARENTHESIS:
      *firstcharptr = firstchar;
-Line 3782 
 for (;; ptr++)
+Line 4739 
 for (;; ptr++)
      previous = NULL;
      if ((options & PCRE_MULTILINE) != 0)
        {
-       if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
+       if (firstcharflags == REQ_UNSET)
+         zerofirstcharflags = firstcharflags = REQ_NONE;
        *code++ = OP_CIRCM;
        }
      else *code++ = OP_CIRC;
-Line 3830 
 for (;; ptr++)
+Line 4788 
 for (;; ptr++)
        }
      goto NORMAL_CHAR;
+     /* In another (POSIX) regex library, the ugly syntax [[:<:]] and [[:>:]] is
+     used for "start of word" and "end of word". As these are otherwise illegal
+     sequences, we don't break anything by recognizing them. They are replaced
+     by \b(?=\w) and \b(?<=\w) respectively. Sequences like [a[:<:]] are
+     erroneous and are handled by the normal code below. */
      case CHAR_LEFT_SQUARE_BRACKET:
+     if (STRNCMP_UC_C8(ptr+1, STRING_WEIRD_STARTWORD, 6) == 0)
+       {
+       nestptr = ptr + 7;
+       ptr = sub_start_of_word - 1;
+       continue;
+       }
+     if (STRNCMP_UC_C8(ptr+1, STRING_WEIRD_ENDWORD, 6) == 0)
+       {
+       nestptr = ptr + 7;
+       ptr = sub_end_of_word - 1;
+       continue;
+       }
+     /* Handle a real character class. */
      previous = code;
      /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
-Line 3887 
 for (;; ptr++)
+Line 4867 
 for (;; ptr++)
      should_flip_negation = FALSE;
+     /* Extended class (xclass) will be used when characters > 255
+     might match. */
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     xclass = FALSE;
+     class_uchardata = code + LINK_SIZE + 2;   /* For XCLASS items */
+     class_uchardata_base = class_uchardata;   /* Save the start */
+ #endif
      /* For optimization purposes, we track some properties of the class:
      class_has_8bitchar will be non-zero if the class contains at least one <
 character; class_one_char will be 1 if the class contains just one
-     character. */
+     character; xclass_has_prop will be TRUE if unicode property checks
+     are present in the class. */
      class_has_8bitchar = 0;
      class_one_char = 0;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     xclass_has_prop = FALSE;
+ #endif
      /* Initialize the 32-char bit map to all zeros. We build the map in a
      temporary bit of memory, in case the class contains fewer than two
-Line 3902 
 for (;; ptr++)
+Line 4895 
 for (;; ptr++)
      memset(classbits, 0, 32 * sizeof(pcre_uint8));
- #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
-     xclass = FALSE;
-     class_uchardata = code + LINK_SIZE + 2;   /* For XCLASS items */
-     class_uchardata_base = class_uchardata;   /* Save the start */
- #endif
      /* Process characters until ] is reached. By writing this as a "do" it
      means that an initial ] is taken as a data character. At the start of the
      loop, c contains the first byte of the character. */
-Line 3933 
 for (;; ptr++)
+Line 4920 
 for (;; ptr++)
        if (lengthptr != NULL && class_uchardata > class_uchardata_base)
          {
          xclass = TRUE;
-         *lengthptr += class_uchardata - class_uchardata_base;
+         *lengthptr += (int)(class_uchardata - class_uchardata_base);
          class_uchardata = class_uchardata_base;
          }
  #endif
-Line 3995 
 for (;; ptr++)
+Line 4982 
 for (;; ptr++)
            posix_class = 0;
          /* When PCRE_UCP is set, some of the POSIX classes are converted to
-         different escape sequences that use Unicode properties. */
+         different escape sequences that use Unicode properties \p or \P. Others
+         that are not available via \p or \P generate XCL_PROP/XCL_NOTPROP
+         directly. */
  #ifdef SUPPORT_UCP
          if ((options & PCRE_UCP) != 0)
            {
+           unsigned int ptype = 0;
            int pc = posix_class + ((local_negate)? POSIX_SUBSIZE/2 : 0);
+           /* The posix_substitutes table specifies which POSIX classes can be
+           converted to \p or \P items. */
            if (posix_substitutes[pc] != NULL)
              {
              nestptr = tempptr + 1;
              ptr = posix_substitutes[pc] - 1;
              continue;
              }
+           /* There are three other classes that generate special property calls
+           that are recognized only in an XCLASS. */
+           else switch(posix_class)
+             {
+             case PC_GRAPH:
+             ptype = PT_PXGRAPH;
+             /* Fall through */
+             case PC_PRINT:
+             if (ptype == 0) ptype = PT_PXPRINT;
+             /* Fall through */
+             case PC_PUNCT:
+             if (ptype == 0) ptype = PT_PXPUNCT;
+             *class_uchardata++ = local_negate? XCL_NOTPROP : XCL_PROP;
+             *class_uchardata++ = ptype;
+             *class_uchardata++ = 0;
+             xclass_has_prop = TRUE;
+             ptr = tempptr + 1;
+             continue;
+             /* For all other POSIX classes, no special action is taken in UCP
+             mode. Fall through to the non_UCP case. */
+             default:
+             break;
+             }
            }
  #endif
-         /* In the non-UCP case, we build the bit map for the POSIX class in a
+         /* In the non-UCP case, or when UCP makes no difference, we build the
-         chunk of local store because we may be adding and subtracting from it,
+         bit map for the POSIX class in a chunk of local store because we may be
-         and we don't want to subtract bits that may be in the main map already.
+         adding and subtracting from it, and we don't want to subtract bits that
-         At the end we or the result into the bit map that is being built. */
+         may be in the main map already. At the end we or the result into the
+         bit map that is being built. */
          posix_class *= 3;
-Line 4129 
 for (;; ptr++)
+Line 5151 
 for (;; ptr++)
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
              continue;
-             /* Perl 5.004 onwards omits VT from \s, but we must preserve it
+             /* Perl 5.004 onwards omitted VT from \s, but restored it at Perl
-             if it was previously set by something earlier in the character
+.18. Before PCRE 8.34, we had to preserve the VT bit if it was
-             class. Luckily, the value of CHAR_VT is 0x0b in both ASCII and
+             previously set by something earlier in the character class.
-             EBCDIC, so we lazily just adjust the appropriate bit. */
+             Luckily, the value of CHAR_VT is 0x0b in both ASCII and EBCDIC, so
+             we could just adjust the appropriate bit. From PCRE 8.34 we no
+             longer treat \s and \S specially. */
              case ESC_s:
-             classbits[0] |= cbits[cbit_space];
+             for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
-             classbits[1] |= cbits[cbit_space+1] & ~0x08;
-             for (c = 2; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
              continue;
              case ESC_S:
              should_flip_negation = TRUE;
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
-             classbits[1] |= 0x08;    /* Perl 5.004 onwards omits VT from \s */
              continue;
              /* The rest apply in both UCP and non-UCP cases. */
-Line 4180 
 for (;; ptr++)
+Line 5201 
 for (;; ptr++)
                  XCL_PROP : XCL_NOTPROP;
                *class_uchardata++ = ptype;
                *class_uchardata++ = pdata;
+               xclass_has_prop = TRUE;
                class_has_8bitchar--;                /* Undo! */
                continue;
                }
-Line 4265 
 for (;; ptr++)
+Line 5287 
 for (;; ptr++)
  #endif
          d = *ptr;  /* Not UTF-8 mode */
-         /* The second part of a range can be a single-character escape, but
+         /* The second part of a range can be a single-character escape
-         not any of the other escapes. Perl 5.6 treats a hyphen as a literal
+         sequence, but not any of the other escapes. Perl treats a hyphen as a
-         in such circumstances. */
+         literal in such circumstances. However, in Perl's warning mode, a
+         warning is given, so PCRE now faults it as it is almost certainly a
+         mistake on the user's part. */
-         if (!inescq && d == CHAR_BACKSLASH)
+         if (!inescq)
            {
-           int descape;
+           if (d == CHAR_BACKSLASH)
-           descape = check_escape(&ptr, &d, errorcodeptr, cd->bracount, options, TRUE);
+             {
-           if (*errorcodeptr != 0) goto FAILED;
+             int descape;
+             descape = check_escape(&ptr, &d, errorcodeptr, cd->bracount, options, TRUE);
+             if (*errorcodeptr != 0) goto FAILED;
-           /* \b is backspace; any other special means the '-' was literal. */
+             /* 0 means a character was put into d; \b is backspace; any other
+             special causes an error. */
-           if (descape != 0)
+             if (descape != 0)
-             {
-             if (descape == ESC_b) d = CHAR_BS; else
                {
-               ptr = oldptr;
+               if (descape == ESC_b) d = CHAR_BS; else
-               goto CLASS_SINGLE_CHARACTER;  /* A few lines below */
+                 {
+                 *errorcodeptr = ERR83;
+                 goto FAILED;
+                 }
                }
              }
+           /* A hyphen followed by a POSIX class is treated in the same way. */
+           else if (d == CHAR_LEFT_SQUARE_BRACKET &&
+                    (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
+                     ptr[1] == CHAR_EQUALS_SIGN) &&
+                    check_posix_syntax(ptr, &tempptr))
+             {
+             *errorcodeptr = ERR83;
+             goto FAILED;
+             }
            }
          /* Check that the two values are in the correct order. Optimize
-Line 4331 
 for (;; ptr++)
+Line 5370 
 for (;; ptr++)
        whatever repeat count may follow. In the case of reqchar, save the
        previous value for reinstating. */
-       if (class_one_char == 1 && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
+       if (!inescq && class_one_char == 1 && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
          {
          ptr++;
          zeroreqchar = reqchar;
-Line 4457 
 for (;; ptr++)
+Line 5496 
 for (;; ptr++)
        *code++ = OP_XCLASS;
        code += LINK_SIZE;
        *code = negate_class? XCL_NOT:0;
+       if (xclass_has_prop) *code |= XCL_HASPROP;
        /* If the map is required, move up the extra data to make room for it;
        otherwise just move the code pointer to the end of the extra data. */
-Line 4466 
 for (;; ptr++)
+Line 5506 
 for (;; ptr++)
          *code++ |= XCL_MAP;
          memmove(code + (32 / sizeof(pcre_uchar)), code,
            IN_UCHARS(class_uchardata - code));
+         if (negate_class && !xclass_has_prop)
+           for (c = 0; c < 32; c++) classbits[c] = ~classbits[c];
          memcpy(code, classbits, 32);
          code = class_uchardata + (32 / sizeof(pcre_uchar));
          }
-Line 4478 
 for (;; ptr++)
+Line 5520 
 for (;; ptr++)
        }
  #endif
+     /* Even though any XCLASS list is now discarded, we must allow for
+     its memory. */
+     if (lengthptr != NULL)
+       *lengthptr += (int)(class_uchardata - class_uchardata_base);
      /* If there are no characters > 255, or they are all to be included or
      excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the
      whole class was negated and whether there were negative specials such as \S
-Line 4548 
 for (;; ptr++)
+Line 5596 
 for (;; ptr++)
      tempcode = previous;
+     /* Before checking for a possessive quantifier, we must skip over
+     whitespace and comments in extended mode because Perl allows white space at
+     this point. */
+     if ((options & PCRE_EXTENDED) != 0)
+       {
+       const pcre_uchar *p = ptr + 1;
+       for (;;)
+         {
+         while (MAX_255(*p) && (cd->ctypes[*p] & ctype_space) != 0) p++;
+         if (*p != CHAR_NUMBER_SIGN) break;
+         p++;
+         while (*p != CHAR_NULL)
+           {
+           if (IS_NEWLINE(p))         /* For non-fixed-length newline cases, */
+             {                        /* IS_NEWLINE sets cd->nllen. */
+             p += cd->nllen;
+             break;
+             }
+           p++;
+ #ifdef SUPPORT_UTF
+           if (utf) FORWARDCHAR(p);
+ #endif
+           }           /* Loop for comment characters */
+         }             /* Loop for multiple comments */
+       ptr = p - 1;    /* Character before the next significant one. */
+       }
      /* If the next character is '+', we have a possessive quantifier. This
      implies greediness, whatever the setting of the PCRE_UNGREEDY option.
      If the next character is '?' this is a minimizing repeat, by default,
-Line 4642 
 for (;; ptr++)
+Line 5718 
 for (;; ptr++)
            }
          }
-       /* If the repetition is unlimited, it pays to see if the next thing on
-       the line is something that cannot possibly match this character. If so,
-       automatically possessifying this item gains some performance in the case
-       where the match fails. */
-       if (!possessive_quantifier &&
-           repeat_max < 0 &&
-           check_auto_possessive(previous, utf, ptr + 1, options, cd))
-         {
-         repeat_type = 0;    /* Force greedy */
-         possessive_quantifier = TRUE;
-         }
        goto OUTPUT_SINGLE_REPEAT;   /* Code shared with single character types */
        }
-Line 4672 
 for (;; ptr++)
+Line 5735 
 for (;; ptr++)
        op_type = OP_TYPESTAR - OP_STAR;  /* Use type opcodes */
        c = *previous;
-       if (!possessive_quantifier &&
-           repeat_max < 0 &&
-           check_auto_possessive(previous, utf, ptr + 1, options, cd))
-         {
-         repeat_type = 0;    /* Force greedy */
-         possessive_quantifier = TRUE;
-         }
        OUTPUT_SINGLE_REPEAT:
        if (*previous == OP_PROP || *previous == OP_NOTPROP)
          {
-Line 4861 
 for (;; ptr++)
+Line 5916 
 for (;; ptr++)
      opcodes such as BRA and CBRA, as this is the place where they get converted
      into the more special varieties such as BRAPOS and SBRA. A test for >=
      OP_ASSERT and <= OP_COND includes ASSERT, ASSERT_NOT, ASSERTBACK,
-     ASSERTBACK_NOT, ONCE, BRA, CBRA, and COND. Originally, PCRE did not allow
+     ASSERTBACK_NOT, ONCE, ONCE_NC, BRA, BRAPOS, CBRA, CBRAPOS, and COND.
-     repetition of assertions, but now it does, for Perl compatibility. */
+     Originally, PCRE did not allow repetition of assertions, but now it does,
+     for Perl compatibility. */
      else if (*previous >= OP_ASSERT && *previous <= OP_COND)
        {
-Line 4880 
 for (;; ptr++)
+Line 5936 
 for (;; ptr++)
        /* There is no sense in actually repeating assertions. The only potential
        use of repetition is in cases when the assertion is optional. Therefore,
        if the minimum is greater than zero, just ignore the repeat. If the
-       maximum is not not zero or one, set it to 1. */
+       maximum is not zero or one, set it to 1. */
        if (*previous < OP_ONCE)    /* Assertion */
          {
-Line 4922 
 for (;; ptr++)
+Line 5978 
 for (;; ptr++)
          if (repeat_max <= 1)    /* Covers 0, 1, and unlimited */
            {
            *code = OP_END;
-           adjust_recurse(previous, 1, utf, cd, save_hwm);
+           adjust_recurse(previous, 1, utf, cd, save_hwm_offset);
            memmove(previous + 1, previous, IN_UCHARS(len));
            code++;
            if (repeat_max == 0)
-Line 4946 
 for (;; ptr++)
+Line 6002 
 for (;; ptr++)
            {
            int offset;
            *code = OP_END;
-           adjust_recurse(previous, 2 + LINK_SIZE, utf, cd, save_hwm);
+           adjust_recurse(previous, 2 + LINK_SIZE, utf, cd, save_hwm_offset);
            memmove(previous + 2 + LINK_SIZE, previous, IN_UCHARS(len));
            code += 2 + LINK_SIZE;
            *previous++ = OP_BRAZERO + repeat_type;
-Line 5009 
 for (;; ptr++)
+Line 6065 
 for (;; ptr++)
              for (i = 1; i < repeat_min; i++)
                {
                pcre_uchar *hc;
-               pcre_uchar *this_hwm = cd->hwm;
+               size_t this_hwm_offset = cd->hwm - cd->start_workspace;
                memcpy(code, previous, IN_UCHARS(len));
                while (cd->hwm > cd->start_workspace + cd->workspace_size -
-                      WORK_SIZE_SAFETY_MARGIN - (this_hwm - save_hwm))
+                      WORK_SIZE_SAFETY_MARGIN -
+                      (this_hwm_offset - save_hwm_offset))
                  {
-                 int save_offset = save_hwm - cd->start_workspace;
-                 int this_offset = this_hwm - cd->start_workspace;
                  *errorcodeptr = expand_workspace(cd);
                  if (*errorcodeptr != 0) goto FAILED;
-                 save_hwm = (pcre_uchar *)cd->start_workspace + save_offset;
-                 this_hwm = (pcre_uchar *)cd->start_workspace + this_offset;
                  }
-               for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
+               for (hc = (pcre_uchar *)cd->start_workspace + save_hwm_offset;
+                    hc < (pcre_uchar *)cd->start_workspace + this_hwm_offset;
+                    hc += LINK_SIZE)
                  {
                  PUT(cd->hwm, 0, GET(hc, 0) + len);
                  cd->hwm += LINK_SIZE;
                  }
-               save_hwm = this_hwm;
+               save_hwm_offset = this_hwm_offset;
                code += len;
                }
              }
-Line 5073 
 for (;; ptr++)
+Line 6128 
 for (;; ptr++)
          else for (i = repeat_max - 1; i >= 0; i--)
            {
            pcre_uchar *hc;
-           pcre_uchar *this_hwm = cd->hwm;
+           size_t this_hwm_offset = cd->hwm - cd->start_workspace;
            *code++ = OP_BRAZERO + repeat_type;
-Line 5095 
 for (;; ptr++)
+Line 6150 
 for (;; ptr++)
            copying them. */
            while (cd->hwm > cd->start_workspace + cd->workspace_size -
-                  WORK_SIZE_SAFETY_MARGIN - (this_hwm - save_hwm))
+                  WORK_SIZE_SAFETY_MARGIN -
+                  (this_hwm_offset - save_hwm_offset))
              {
-             int save_offset = save_hwm - cd->start_workspace;
-             int this_offset = this_hwm - cd->start_workspace;
              *errorcodeptr = expand_workspace(cd);
              if (*errorcodeptr != 0) goto FAILED;
-             save_hwm = (pcre_uchar *)cd->start_workspace + save_offset;
-             this_hwm = (pcre_uchar *)cd->start_workspace + this_offset;
              }
-           for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
+           for (hc = (pcre_uchar *)cd->start_workspace + save_hwm_offset;
+                hc < (pcre_uchar *)cd->start_workspace + this_hwm_offset;
+                hc += LINK_SIZE)
              {
              PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));
              cd->hwm += LINK_SIZE;
              }
-           save_hwm = this_hwm;
+           save_hwm_offset = this_hwm_offset;
            code += len;
            }
-Line 5206 
 for (;; ptr++)
+Line 6260 
 for (;; ptr++)
                {
                int nlen = (int)(code - bracode);
                *code = OP_END;
-               adjust_recurse(bracode, 1 + LINK_SIZE, utf, cd, save_hwm);
+               adjust_recurse(bracode, 1 + LINK_SIZE, utf, cd, save_hwm_offset);
                memmove(bracode + 1 + LINK_SIZE, bracode, IN_UCHARS(nlen));
                code += 1 + LINK_SIZE;
                nlen += 1 + LINK_SIZE;
-Line 5253 
 for (;; ptr++)
+Line 6307 
 for (;; ptr++)
        goto FAILED;
        }
-     /* If the character following a repeat is '+', or if certain optimization
+     /* If the character following a repeat is '+', possessive_quantifier is
-     tests above succeeded, possessive_quantifier is TRUE. For some opcodes,
+     TRUE. For some opcodes, there are special alternative opcodes for this
-     there are special alternative opcodes for this case. For anything else, we
+     case. For anything else, we wrap the entire repeated item inside OP_ONCE
-     wrap the entire repeated item inside OP_ONCE brackets. Logically, the '+'
+     brackets. Logically, the '+' notation is just syntactic sugar, taken from
-     notation is just syntactic sugar, taken from Sun's Java package, but the
+     Sun's Java package, but the special opcodes can optimize it.
-     special opcodes can optimize it.
      Some (but not all) possessively repeated subpatterns have already been
      completely handled in the code just above. For them, possessive_quantifier
-     is always FALSE at this stage.
+     is always FALSE at this stage. Note that the repeated item starts at
+     tempcode, not at previous, which might be the first part of a string whose
-     Note that the repeated item starts at tempcode, not at previous, which
+     (former) last char we repeated. */
-     might be the first part of a string whose (former) last char we repeated.
-     Possessifying an 'exact' quantifier has no effect, so we can ignore it. But
-     an 'upto' may follow. We skip over an 'exact' item, and then test the
-     length of what remains before proceeding. */
      if (possessive_quantifier)
        {
        int len;
-       if (*tempcode == OP_TYPEEXACT)
+       /* Possessifying an EXACT quantifier has no effect, so we can ignore it.
+       However, QUERY, STAR, or UPTO may follow (for quantifiers such as {5,6},
+       {5,}, or {5,10}). We skip over an EXACT item; if the length of what
+       remains is greater than zero, there's a further opcode that can be
+       handled. If not, do nothing, leaving the EXACT alone. */
+       switch(*tempcode)
+         {
+         case OP_TYPEEXACT:
          tempcode += PRIV(OP_lengths)[*tempcode] +
            ((tempcode[1 + IMM2_SIZE] == OP_PROP
            || tempcode[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0);
+         break;
-       else if (*tempcode == OP_EXACT || *tempcode == OP_NOTEXACT)
+         /* CHAR opcodes are used for exacts whose count is 1. */
-         {
+         case OP_CHAR:
+         case OP_CHARI:
+         case OP_NOT:
+         case OP_NOTI:
+         case OP_EXACT:
+         case OP_EXACTI:
+         case OP_NOTEXACT:
+         case OP_NOTEXACTI:
          tempcode += PRIV(OP_lengths)[*tempcode];
  #ifdef SUPPORT_UTF
          if (utf && HAS_EXTRALEN(tempcode[-1]))
            tempcode += GET_EXTRALEN(tempcode[-1]);
  #endif
+         break;
+         /* For the class opcodes, the repeat operator appears at the end;
+         adjust tempcode to point to it. */
+         case OP_CLASS:
+         case OP_NCLASS:
+         tempcode += 1 + 32/sizeof(pcre_uchar);
+         break;
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+         case OP_XCLASS:
+         tempcode += GET(tempcode, 1);
+         break;
+ #endif
          }
+       /* If tempcode is equal to code (which points to the end of the repeated
+       item), it means we have skipped an EXACT item but there is no following
+       QUERY, STAR, or UPTO; the value of len will be 0, and we do nothing. In
+       all other cases, tempcode will be pointing to the repeat opcode, and will
+       be less than code, so the value of len will be greater than 0. */
        len = (int)(code - tempcode);
+       if (len > 0)
+         {
+         unsigned int repcode = *tempcode;
+         /* There is a table for possessifying opcodes, all of which are less
+         than OP_CALLOUT. A zero entry means there is no possessified version.
+         */
+         if (repcode < OP_CALLOUT && opcode_possessify[repcode] > 0)
+           *tempcode = opcode_possessify[repcode];
+         /* For opcode without a special possessified version, wrap the item in
+         ONCE brackets. Because we are moving code along, we must ensure that any
+         pending recursive references are updated. */
+         else
+           {
+           *code = OP_END;
+           adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, save_hwm_offset);
+           memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));
+           code += 1 + LINK_SIZE;
+           len += 1 + LINK_SIZE;
+           tempcode[0] = OP_ONCE;
+           *code++ = OP_KET;
+           PUTINC(code, 0, len);
+           PUT(tempcode, 1, len);
+           }
+         }
+ #ifdef NEVER
        if (len > 0) switch (*tempcode)
          {
          case OP_STAR:  *tempcode = OP_POSSTAR; break;
-Line 5317 
 for (;; ptr++)
+Line 6433 
 for (;; ptr++)
          case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;
          case OP_TYPEUPTO:  *tempcode = OP_TYPEPOSUPTO; break;
+         case OP_CRSTAR:   *tempcode = OP_CRPOSSTAR; break;
+         case OP_CRPLUS:   *tempcode = OP_CRPOSPLUS; break;
+         case OP_CRQUERY:  *tempcode = OP_CRPOSQUERY; break;
+         case OP_CRRANGE:  *tempcode = OP_CRPOSRANGE; break;
          /* Because we are moving code along, we must ensure that any
          pending recursive references are updated. */
          default:
          *code = OP_END;
-         adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, save_hwm);
+         adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, save_hwm_offset);
          memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));
          code += 1 + LINK_SIZE;
          len += 1 + LINK_SIZE;
-Line 5332 
 for (;; ptr++)
+Line 6453 
 for (;; ptr++)
          PUT(tempcode, 1, len);
          break;
          }
+ #endif
        }
      /* In all case we no longer have a previous item. We also set the
-Line 5350 
 for (;; ptr++)
+Line 6472 
 for (;; ptr++)
      parenthesis forms.  */
      case CHAR_LEFT_PARENTHESIS:
-     newoptions = options;
+     ptr++;
-     skipbytes = 0;
-     bravalue = OP_CBRA;
-     save_hwm = cd->hwm;
-     reset_bracount = FALSE;
-     /* First deal with various "verbs" that can be introduced by '*'. */
+     /* First deal with comments. Putting this code right at the start ensures
+     that comments have no bad side effects. */
+     if (ptr[0] == CHAR_QUESTION_MARK && ptr[1] == CHAR_NUMBER_SIGN)
+       {
+       ptr += 2;
+       while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
+       if (*ptr == CHAR_NULL)
+         {
+         *errorcodeptr = ERR18;
+         goto FAILED;
+         }
+       continue;
+       }
+     /* Now deal with various "verbs" that can be introduced by '*'. */
-     ptr++;
      if (ptr[0] == CHAR_ASTERISK && (ptr[1] == ':'
           || (MAX_255(ptr[1]) && ((cd->ctypes[ptr[1]] & ctype_letter) != 0))))
        {
-Line 5479 
 for (;; ptr++)
+Line 6611 
 for (;; ptr++)
        goto FAILED;
        }
+     /* Initialize for "real" parentheses */
+     newoptions = options;
+     skipbytes = 0;
+     bravalue = OP_CBRA;
+     save_hwm_offset = cd->hwm - cd->start_workspace;
+     reset_bracount = FALSE;
      /* Deal with the extended parentheses; all are introduced by '?', and the
      appearance of any of them means that this is not a capturing group. */
-     else if (*ptr == CHAR_QUESTION_MARK)
+     if (*ptr == CHAR_QUESTION_MARK)
        {
        int i, set, unset, namelen;
        int *optset;
-Line 5491 
 for (;; ptr++)
+Line 6631 
 for (;; ptr++)
        switch (*(++ptr))
          {
-         case CHAR_NUMBER_SIGN:                 /* Comment; skip to ket */
-         ptr++;
-         while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
-         if (*ptr == CHAR_NULL)
-           {
-           *errorcodeptr = ERR18;
-           goto FAILED;
-           }
-         continue;
          /* ------------------------------------------------------------ */
          case CHAR_VERTICAL_LINE:  /* Reset capture count for each branch */
          reset_bracount = TRUE;
-Line 5520 
 for (;; ptr++)
+Line 6649 
 for (;; ptr++)
          tempptr = ptr;
          /* A condition can be an assertion, a number (referring to a numbered
-         group), a name (referring to a named group), or 'R', referring to
+         group's having been set), a name (referring to a named group), or 'R',
-         recursion. R<digits> and R&name are also permitted for recursion tests.
+         referring to recursion. R<digits> and R&name are also permitted for
+         recursion tests.
-         There are several syntaxes for testing a named group: (?(name)) is used
-         by Python; Perl 5.10 onwards uses (?(<name>) or (?('name')).
+         There are ways of testing a named group: (?(name)) is used by Python;
+         Perl 5.10 onwards uses (?(<name>) or (?('name')).
-         There are two unfortunate ambiguities, caused by history. (a) 'R' can
-         be the recursive thing or the name 'R' (and similarly for 'R' followed
+         There is one unfortunate ambiguity, caused by history. 'R' can be the
-         by digits), and (b) a number could be a name that consists of digits.
+         recursive thing or the name 'R' (and similarly for 'R' followed by
-         In both cases, we look for a name first; if not found, we try the other
+         digits). We look for a name first; if not found, we try the other case.
-         cases.
          For compatibility with auto-callouts, we allow a callout to be
          specified before a condition that is an assertion. First, check for the
-Line 5552 
 for (;; ptr++)
+Line 6680 
 for (;; ptr++)
                (tempptr[2] == CHAR_EQUALS_SIGN ||
                 tempptr[2] == CHAR_EXCLAMATION_MARK ||
                 tempptr[2] == CHAR_LESS_THAN_SIGN))
+           {
+           cd->iscondassert = TRUE;
            break;
+           }
-         /* Most other conditions use OP_CREF (a couple change to OP_RREF
+         /* Other conditions use OP_CREF/OP_DNCREF/OP_RREF/OP_DNRREF, and all
-         below), and all need to skip 1+IMM2_SIZE bytes at the start of the group. */
+         need to skip at least 1+IMM2_SIZE bytes at the start of the group. */
          code[1+LINK_SIZE] = OP_CREF;
          skipbytes = 1+IMM2_SIZE;
-         refsign = -1;
+         refsign = -1;     /* => not a number */
+         namelen = -1;     /* => not a name; must set to avoid warning */
+         name = NULL;      /* Always set to avoid warning */
+         recno = 0;        /* Always set to avoid warning */
          /* Check for a test for recursion in a named group. */
-         if (ptr[1] == CHAR_R && ptr[2] == CHAR_AMPERSAND)
+         ptr++;
+         if (*ptr == CHAR_R && ptr[1] == CHAR_AMPERSAND)
            {
            terminator = -1;
            ptr += 2;
-Line 5571 
 for (;; ptr++)
+Line 6706 
 for (;; ptr++)
            }
          /* Check for a test for a named group's having been set, using the Perl
-         syntax (?(<name>) or (?('name') */
+         syntax (?(<name>) or (?('name'), and also allow for the original PCRE
+         syntax of (?(name) or for (?(+n), (?(-n), and just (?(n). */
-         else if (ptr[1] == CHAR_LESS_THAN_SIGN)
+         else if (*ptr == CHAR_LESS_THAN_SIGN)
            {
            terminator = CHAR_GREATER_THAN_SIGN;
            ptr++;
            }
-         else if (ptr[1] == CHAR_APOSTROPHE)
+         else if (*ptr == CHAR_APOSTROPHE)
            {
            terminator = CHAR_APOSTROPHE;