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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 275 by ph10,
Wed Nov 21 15:35:09 2007 UTC
+revision 507 by ph10,
Wed Mar 10 16:08:01 2010 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2007 University of Cambridge
+            Copyright (c) 1997-2010 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 53 
 supporting internal functions that are n
  #include "pcre_internal.h"
- /* When DEBUG is defined, we need the pcre_printint() function, which is also
+ /* When PCRE_DEBUG is defined, we need the pcre_printint() function, which is
- used by pcretest. DEBUG is not defined when building a production library. */
+ also used by pcretest. PCRE_DEBUG is not defined when building a production
+ library. */
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  #include "pcre_printint.src"
  #endif
-Line 91 
 is 4 there is plenty of room. */
+Line 92 
 is 4 there is plenty of room. */
  #define COMPILE_WORK_SIZE (4096)
+ /* The overrun tests check for a slightly smaller size so that they detect the
+ overrun before it actually does run off the end of the data block. */
+ #define WORK_SIZE_CHECK (COMPILE_WORK_SIZE - 100)
  /* Table for handling escaped characters in the range '0'-'z'. Positive returns
  are simple data values; negative values are for special things like \d and so
  on. Zero means further processing is needed (for things like \x), or the escape
  is invalid. */
- #ifndef EBCDIC  /* This is the "normal" table for ASCII systems */
+ #ifndef EBCDIC
+ /* This is the "normal" table for ASCII systems or for EBCDIC systems running
+ in UTF-8 mode. */
  static const short int escapes[] = {
-,      0,      0,      0,      0,      0,      0,      0,   /* 0 - 7 */
+,                       0,
-,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */
+,                       0,
-    '@', -ESC_A, -ESC_B, -ESC_C, -ESC_D, -ESC_E,      0, -ESC_G,   /* @ - G */
+,                       0,
- -ESC_H,      0,      0, -ESC_K,      0,      0,      0,      0,   /* H - O */
+,                       0,
- -ESC_P, -ESC_Q, -ESC_R, -ESC_S,      0,      0, -ESC_V, -ESC_W,   /* P - W */
+,                       0,
- -ESC_X,      0, -ESC_Z,    '[',   '\\',    ']',    '^',    '_',   /* X - _ */
+      CHAR_COLON,              CHAR_SEMICOLON,
-    '`',      7, -ESC_b,      0, -ESC_d,  ESC_e,  ESC_f,      0,   /* ` - g */
+      CHAR_LESS_THAN_SIGN,     CHAR_EQUALS_SIGN,
- -ESC_h,      0,      0, -ESC_k,      0,      0,  ESC_n,      0,   /* h - o */
+      CHAR_GREATER_THAN_SIGN,  CHAR_QUESTION_MARK,
- -ESC_p,      0,  ESC_r, -ESC_s,  ESC_tee,    0, -ESC_v, -ESC_w,   /* p - w */
+      CHAR_COMMERCIAL_AT,      -ESC_A,
-,      0, -ESC_z                                            /* x - z */
+      -ESC_B,                  -ESC_C,
+      -ESC_D,                  -ESC_E,
+,                       -ESC_G,
+      -ESC_H,                  0,
+,                       -ESC_K,
+,                       0,
+,                       0,
+      -ESC_P,                  -ESC_Q,
+      -ESC_R,                  -ESC_S,
+,                       0,
+      -ESC_V,                  -ESC_W,
+      -ESC_X,                  0,
+      -ESC_Z,                  CHAR_LEFT_SQUARE_BRACKET,
+      CHAR_BACKSLASH,          CHAR_RIGHT_SQUARE_BRACKET,
+      CHAR_CIRCUMFLEX_ACCENT,  CHAR_UNDERSCORE,
+      CHAR_GRAVE_ACCENT,       7,
+      -ESC_b,                  0,
+      -ESC_d,                  ESC_e,
+      ESC_f,                   0,
+      -ESC_h,                  0,
+,                       -ESC_k,
+,                       0,
+      ESC_n,                   0,
+      -ESC_p,                  0,
+      ESC_r,                   -ESC_s,
+      ESC_tee,                 0,
+      -ESC_v,                  -ESC_w,
+,                       0,
+      -ESC_z
  };
- #else           /* This is the "abnormal" table for EBCDIC systems */
+ #else
+ /* This is the "abnormal" table for EBCDIC systems without UTF-8 support. */
  static const short int escapes[] = {
  /*  48 */     0,     0,      0,     '.',    '<',   '(',    '+',    '|',
  /*  50 */   '&',     0,      0,       0,      0,     0,      0,      0,
-Line 142 
 static const short int escapes[] = {
+Line 183 
 static const short int escapes[] = {
  /* Table of special "verbs" like (*PRUNE). This is a short table, so it is
  searched linearly. Put all the names into a single string, in order to reduce
- the number of relocations when a shared library is dynamically linked. */
+ the number of relocations when a shared library is dynamically linked. The
+ string is built from string macros so that it works in UTF-8 mode on EBCDIC
+ platforms. */
  typedef struct verbitem {
    int   len;
-Line 150 
 typedef struct verbitem {
+Line 193 
 typedef struct verbitem {
  } verbitem;
  static const char verbnames[] =
-   "ACCEPT\0"
+   STRING_ACCEPT0
-   "COMMIT\0"
+   STRING_COMMIT0
-   "F\0"
+   STRING_F0
-   "FAIL\0"
+   STRING_FAIL0
-   "PRUNE\0"
+   STRING_PRUNE0
-   "SKIP\0"
+   STRING_SKIP0
-   "THEN";
+   STRING_THEN;
- static verbitem verbs[] = {
+ static const verbitem verbs[] = {
    { 6, OP_ACCEPT },
    { 6, OP_COMMIT },
    { 1, OP_FAIL },
-Line 168 
 static verbitem verbs[] = {
+Line 211 
 static verbitem verbs[] = {
    { 4, OP_THEN  }
  };
- static int verbcount = sizeof(verbs)/sizeof(verbitem);
+ static const int verbcount = sizeof(verbs)/sizeof(verbitem);
  /* Tables of names of POSIX character classes and their lengths. The names are
-Line 178 
 length entry. The first three must be al
+Line 221 
 length entry. The first three must be al
  for handling case independence. */
  static const char posix_names[] =
-   "alpha\0"  "lower\0"  "upper\0"  "alnum\0"  "ascii\0"  "blank\0"
+   STRING_alpha0 STRING_lower0 STRING_upper0 STRING_alnum0
-   "cntrl\0"  "digit\0"  "graph\0"  "print\0"  "punct\0"  "space\0"
+   STRING_ascii0 STRING_blank0 STRING_cntrl0 STRING_digit0
-   "word\0"   "xdigit";
+   STRING_graph0 STRING_print0 STRING_punct0 STRING_space0
+   STRING_word0  STRING_xdigit;
  static const uschar posix_name_lengths[] = {
 , 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
-Line 224 
 the number of relocations needed when a
+Line 268 
 the number of relocations needed when a
  it is now one long string. We cannot use a table of offsets, because the
  lengths of inserts such as XSTRING(MAX_NAME_SIZE) are not known. Instead, we
  simply count through to the one we want - this isn't a performance issue
- because these strings are used only when there is a compilation error. */
+ because these strings are used only when there is a compilation error.
+ Each substring ends with \0 to insert a null character. This includes the final
+ substring, so that the whole string ends with \0\0, which can be detected when
+ counting through. */
  static const char error_texts[] =
    "no error\0"
-Line 295 
 static const char error_texts[] =
+Line 343 
 static const char error_texts[] =
    /* 55 */
    "repeating a DEFINE group is not allowed\0"
    "inconsistent NEWLINE options\0"
-   "\\g is not followed by a braced name or an optionally braced non-zero number\0"
+   "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
-   "(?+ or (?- or (?(+ or (?(- must be followed by a non-zero number\0"
+   "a numbered reference must not be zero\0"
    "(*VERB) with an argument is not supported\0"
    /* 60 */
    "(*VERB) not recognized\0"
    "number is too big\0"
    "subpattern name expected\0"
-   "digit expected after (?+";
+   "digit expected after (?+\0"
+   "] is an invalid data character in JavaScript compatibility mode\0"
+   /* 65 */
+   "different names for subpatterns of the same number are not allowed\0";
  /* Table to identify digits and hex digits. This is used when compiling
  patterns. Note that the tables in chartables are dependent on the locale, and
-Line 321 
 For convenience, we use the same bit def
+Line 371 
 For convenience, we use the same bit def
  Then we can use ctype_digit and ctype_xdigit in the code. */
- #ifndef EBCDIC  /* This is the "normal" case, for ASCII systems */
+ #ifndef EBCDIC
+ /* This is the "normal" case, for ASCII systems, and EBCDIC systems running in
+ UTF-8 mode. */
  static const unsigned char digitab[] =
    {
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
-Line 357 
 static const unsigned char digitab[] =
+Line 411 
 static const unsigned char digitab[] =
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
- #else           /* This is the "abnormal" case, for EBCDIC systems */
+ #else
+ /* This is the "abnormal" case, for EBCDIC systems not running in UTF-8 mode. */
  static const unsigned char digitab[] =
    {
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7  0 */
-Line 454 
 static const char *
+Line 511 
 static const char *
  find_error_text(int n)
  {
  const char *s = error_texts;
- for (; n > 0; n--) while (*s++ != 0);
+ for (; n > 0; n--)
+   {
+   while (*s++ != 0) {};
+   if (*s == 0) return "Error text not found (please report)";
+   }
  return s;
  }
-Line 502 
 if (c == 0) *errorcodeptr = ERR1;
+Line 563 
 if (c == 0) *errorcodeptr = ERR1;
  in a table. A non-zero result is something that can be returned immediately.
  Otherwise further processing may be required. */
- #ifndef EBCDIC  /* ASCII coding */
+ #ifndef EBCDIC  /* ASCII/UTF-8 coding */
- else if (c < '0' || c > 'z') {}                           /* Not alphanumeric */
+ else if (c < CHAR_0 || c > CHAR_z) {}                     /* Not alphanumeric */
- else if ((i = escapes[c - '0']) != 0) c = i;
+ else if ((i = escapes[c - CHAR_0]) != 0) c = i;
  #else           /* EBCDIC coding */
  else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {}   /* Not alphanumeric */
-Line 523 
 else
+Line 584 
 else
      /* A number of Perl escapes are not handled by PCRE. We give an explicit
      error. */
-     case 'l':
+     case CHAR_l:
-     case 'L':
+     case CHAR_L:
-     case 'N':
+     case CHAR_N:
-     case 'u':
+     case CHAR_u:
-     case 'U':
+     case CHAR_U:
      *errorcodeptr = ERR37;
      break;
-     /* \g must be followed by a number, either plain or braced. If positive, it
+     /* \g must be followed by one of a number of specific things:
-     is an absolute backreference. If negative, it is a relative backreference.
-     This is a Perl 5.10 feature. Perl 5.10 also supports \g{name} as a
+     (1) A number, either plain or braced. If positive, it is an absolute
-     reference to a named group. This is part of Perl's movement towards a
+     backreference. If negative, it is a relative backreference. This is a Perl
-     unified syntax for back references. As this is synonymous with \k{name}, we
+.10 feature.
-     fudge it up by pretending it really was \k. */
+     (2) Perl 5.10 also supports \g{name} as a reference to a named group. This
+     is part of Perl's movement towards a unified syntax for back references. As
+     this is synonymous with \k{name}, we fudge it up by pretending it really
+     was \k.
+     (3) For Oniguruma compatibility we also support \g followed by a name or a
+     number either in angle brackets or in single quotes. However, these are
+     (possibly recursive) subroutine calls, _not_ backreferences. Just return
+     the -ESC_g code (cf \k). */
+     case CHAR_g:
+     if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)
+       {
+       c = -ESC_g;
+       break;
+       }
-     case 'g':
+     /* Handle the Perl-compatible cases */
-     if (ptr[1] == '{')
+     if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
        {
        const uschar *p;
-       for (p = ptr+2; *p != 0 && *p != '}'; p++)
+       for (p = ptr+2; *p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET; p++)
-         if (*p != '-' && (digitab[*p] & ctype_digit) == 0) break;
+         if (*p != CHAR_MINUS && (digitab[*p] & ctype_digit) == 0) break;
-       if (*p != 0 && *p != '}')
+       if (*p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET)
          {
          c = -ESC_k;
          break;
-Line 554 
 else
+Line 632 
 else
        }
      else braced = FALSE;
-     if (ptr[1] == '-')
+     if (ptr[1] == CHAR_MINUS)
        {
        negated = TRUE;
        ptr++;
-Line 563 
 else
+Line 641 
 else
      c = 0;
      while ((digitab[ptr[1]] & ctype_digit) != 0)
-       c = c * 10 + *(++ptr) - '0';
+       c = c * 10 + *(++ptr) - CHAR_0;
-     if (c < 0)
+     if (c < 0)   /* Integer overflow */
        {
        *errorcodeptr = ERR61;
        break;
        }
-     if (c == 0 || (braced && *(++ptr) != '}'))
+     if (braced && *(++ptr) != CHAR_RIGHT_CURLY_BRACKET)
        {
        *errorcodeptr = ERR57;
        break;
        }
+     if (c == 0)
+       {
+       *errorcodeptr = ERR58;
+       break;
+       }
      if (negated)
        {
        if (c > bracount)
-Line 602 
 else
+Line 686 
 else
      value is greater than 377, the least significant 8 bits are taken. Inside a
      character class, \ followed by a digit is always an octal number. */
-     case '1': case '2': case '3': case '4': case '5':
+     case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5:
-     case '6': case '7': case '8': case '9':
+     case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
      if (!isclass)
        {
        oldptr = ptr;
-       c -= '0';
+       c -= CHAR_0;
        while ((digitab[ptr[1]] & ctype_digit) != 0)
-         c = c * 10 + *(++ptr) - '0';
+         c = c * 10 + *(++ptr) - CHAR_0;
-       if (c < 0)
+       if (c < 0)    /* Integer overflow */
          {
          *errorcodeptr = ERR61;
          break;
-Line 628 
 else
+Line 712 
 else
      generates a binary zero byte and treats the digit as a following literal.
      Thus we have to pull back the pointer by one. */
-     if ((c = *ptr) >= '8')
+     if ((c = *ptr) >= CHAR_8)
        {
        ptr--;
        c = 0;
-Line 641 
 else
+Line 725 
 else
      to do). Nowadays we allow for larger numbers in UTF-8 mode, but no more
      than 3 octal digits. */
-     case '0':
+     case CHAR_0:
-     c -= '0';
+     c -= CHAR_0;
-     while(i++ < 2 && ptr[1] >= '0' && ptr[1] <= '7')
+     while(i++ < 2 && ptr[1] >= CHAR_0 && ptr[1] <= CHAR_7)
-         c = c * 8 + *(++ptr) - '0';
+         c = c * 8 + *(++ptr) - CHAR_0;
      if (!utf8 && c > 255) *errorcodeptr = ERR51;
      break;
-Line 652 
 else
+Line 736 
 else
      than 0xff in utf8 mode, but only if the ddd are hex digits. If not, { is
      treated as a data character. */
-     case 'x':
+     case CHAR_x:
-     if (ptr[1] == '{')
+     if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
        {
        const uschar *pt = ptr + 2;
        int count = 0;
-Line 662 
 else
+Line 746 
 else
        while ((digitab[*pt] & ctype_xdigit) != 0)
          {
          register int cc = *pt++;
-         if (c == 0 && cc == '0') continue;     /* Leading zeroes */
+         if (c == 0 && cc == CHAR_0) continue;     /* Leading zeroes */
          count++;
- #ifndef EBCDIC  /* ASCII coding */
+ #ifndef EBCDIC  /* ASCII/UTF-8 coding */
-         if (cc >= 'a') cc -= 32;               /* Convert to upper case */
+         if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
-         c = (c << 4) + cc - ((cc < 'A')? '0' : ('A' - 10));
+         c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
  #else           /* EBCDIC coding */
-         if (cc >= 'a' && cc <= '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 >= '0')? '0' : ('A' - 10));
+         c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
  #endif
          }
-       if (*pt == '}')
+       if (*pt == CHAR_RIGHT_CURLY_BRACKET)
          {
          if (c < 0 || count > (utf8? 8 : 2)) *errorcodeptr = ERR34;
          ptr = pt;
-Line 690 
 else
+Line 774 
 else
      c = 0;
      while (i++ < 2 && (digitab[ptr[1]] & ctype_xdigit) != 0)
        {
-       int cc;                               /* Some compilers don't like ++ */
+       int cc;                                  /* Some compilers don't like */
-       cc = *(++ptr);                        /* in initializers */
+       cc = *(++ptr);                           /* ++ in initializers */
- #ifndef EBCDIC  /* ASCII coding */
+ #ifndef EBCDIC  /* ASCII/UTF-8 coding */
-       if (cc >= 'a') cc -= 32;              /* Convert to upper case */
+       if (cc >= CHAR_a) cc -= 32;              /* Convert to upper case */
-       c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));
+       c = c * 16 + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
  #else           /* EBCDIC coding */
-       if (cc <= 'z') cc += 64;              /* Convert to upper case */
+       if (cc <= CHAR_z) cc += 64;              /* Convert to upper case */
-       c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
+       c = c * 16 + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
  #endif
        }
      break;
-Line 706 
 else
+Line 790 
 else
      This coding is ASCII-specific, but then the whole concept of \cx is
      ASCII-specific. (However, an EBCDIC equivalent has now been added.) */
-     case 'c':
+     case CHAR_c:
      c = *(++ptr);
      if (c == 0)
        {
-Line 714 
 else
+Line 798 
 else
        break;
        }
- #ifndef EBCDIC  /* ASCII coding */
+ #ifndef EBCDIC  /* ASCII/UTF-8 coding */
-     if (c >= 'a' && c <= 'z') c -= 32;
+     if (c >= CHAR_a && c <= CHAR_z) c -= 32;
      c ^= 0x40;
  #else           /* EBCDIC coding */
-     if (c >= 'a' && c <= 'z') c += 64;
+     if (c >= CHAR_a && c <= CHAR_z) c += 64;
      c ^= 0xC0;
  #endif
      break;
-Line 780 
 if (c == 0) goto ERROR_RETURN;
+Line 864 
 if (c == 0) goto ERROR_RETURN;
  /* \P or \p can be followed by a name in {}, optionally preceded by ^ for
  negation. */
- if (c == '{')
+ if (c == CHAR_LEFT_CURLY_BRACKET)
    {
-   if (ptr[1] == '^')
+   if (ptr[1] == CHAR_CIRCUMFLEX_ACCENT)
      {
      *negptr = TRUE;
      ptr++;
-Line 791 
 if (c == '{')
+Line 875 
 if (c == '{')
      {
      c = *(++ptr);
      if (c == 0) goto ERROR_RETURN;
-     if (c == '}') break;
+     if (c == CHAR_RIGHT_CURLY_BRACKET) break;
      name[i] = c;
      }
-   if (c !='}') goto ERROR_RETURN;
+   if (c != CHAR_RIGHT_CURLY_BRACKET) goto ERROR_RETURN;
    name[i] = 0;
    }
-Line 859 
 is_counted_repeat(const uschar *p)
+Line 943 
 is_counted_repeat(const uschar *p)
  {
  if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
  while ((digitab[*p] & ctype_digit) != 0) p++;
- if (*p == '}') return TRUE;
+ if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
- if (*p++ != ',') return FALSE;
+ if (*p++ != CHAR_COMMA) return FALSE;
- if (*p == '}') return TRUE;
+ if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
  if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
  while ((digitab[*p] & ctype_digit) != 0) p++;
- return (*p == '}');
+ return (*p == CHAR_RIGHT_CURLY_BRACKET);
  }
-Line 900 
 int max = -1;
+Line 984 
 int max = -1;
  /* Read the minimum value and do a paranoid check: a negative value indicates
  an integer overflow. */
- while ((digitab[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0';
+ while ((digitab[*p] & ctype_digit) != 0) min = min * 10 + *p++ - CHAR_0;
  if (min < 0 || min > 65535)
    {
    *errorcodeptr = ERR5;
-Line 910 
 if (min < 0 || min > 65535)
+Line 994 
 if (min < 0 || min > 65535)
  /* 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 == '}') max = min; else
+ if (*p == CHAR_RIGHT_CURLY_BRACKET) max = min; else
    {
-   if (*(++p) != '}')
+   if (*(++p) != CHAR_RIGHT_CURLY_BRACKET)
      {
      max = 0;
-     while((digitab[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0';
+     while((digitab[*p] & ctype_digit) != 0) max = max * 10 + *p++ - CHAR_0;
      if (max < 0 || max > 65535)
        {
        *errorcodeptr = ERR5;
-Line 940 
 return p;
+Line 1024 
 return p;
  /*************************************************
- *       Find forward referenced subpattern       *
+ *  Subroutine for finding forward reference      *
  *************************************************/
- /* This function scans along a pattern's text looking for capturing
+ /* This recursive function is called only from find_parens() below. The
+ top-level call starts at the beginning of the pattern. All other calls must
+ start at a parenthesis. It scans along a pattern's text looking for capturing
  subpatterns, and counting them. If it finds a named pattern that matches the
  name it is given, it returns its number. Alternatively, if the name is NULL, it
- returns when it reaches a given numbered subpattern. This is used for forward
+ returns when it reaches a given numbered subpattern. We know that if (?P< is
- references to subpatterns. We know that if (?P< is encountered, the name will
+ encountered, the name will be terminated by '>' because that is checked in the
- be terminated by '>' because that is checked in the first pass.
+ first pass. Recursion is used to keep track of subpatterns that reset the
+ capturing group numbers - the (?| feature.
  Arguments:
-   ptr          current position in the pattern
+   ptrptr       address of the current character pointer (updated)
-   count        current count of capturing parens so far encountered
+   cd           compile background data
    name         name to seek, or NULL if seeking a numbered subpattern
    lorn         name length, or subpattern number if name is NULL
    xmode        TRUE if we are in /x mode
+   count        pointer to the current capturing subpattern number (updated)
  Returns:       the number of the named subpattern, or -1 if not found
  */
  static int
- find_parens(const uschar *ptr, int count, const uschar *name, int lorn,
+ find_parens_sub(uschar **ptrptr, compile_data *cd, const uschar *name, int lorn,
-   BOOL xmode)
+   BOOL xmode, int *count)
  {
- const uschar *thisname;
+ uschar *ptr = *ptrptr;
+ int start_count = *count;
+ int hwm_count = start_count;
+ BOOL dup_parens = FALSE;
- for (; *ptr != 0; ptr++)
+ /* If the first character is a parenthesis, check on the type of group we are
+ dealing with. The very first call may not start with a parenthesis. */
+ if (ptr[0] == CHAR_LEFT_PARENTHESIS)
    {
-   int term;
+   if (ptr[1] == CHAR_QUESTION_MARK &&
+       ptr[2] == CHAR_VERTICAL_LINE)
+     {
+     ptr += 3;
+     dup_parens = TRUE;
+     }
+   /* Handle a normal, unnamed capturing parenthesis */
+   else if (ptr[1] != CHAR_QUESTION_MARK && ptr[1] != CHAR_ASTERISK)
+     {
+     *count += 1;
+     if (name == NULL && *count == lorn) return *count;
+     ptr++;
+     }
+   /* Handle a condition. If it is an assertion, just carry on so that it
+   is processed as normal. If not, skip to the closing parenthesis of the
+   condition (there can't be any nested parens. */
+   else if (ptr[2] == CHAR_LEFT_PARENTHESIS)
+     {
+     ptr += 2;
+     if (ptr[1] != CHAR_QUESTION_MARK)
+       {
+       while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
+       if (*ptr != 0) ptr++;
+       }
+     }
+   /* We have either (? or (* and not a condition */
+   else
+     {
+     ptr += 2;
+     if (*ptr == CHAR_P) ptr++;                      /* Allow optional P */
+     /* We have to disambiguate (?<! and (?<= from (?<name> for named groups */
+     if ((*ptr == CHAR_LESS_THAN_SIGN && ptr[1] != CHAR_EXCLAMATION_MARK &&
+         ptr[1] != CHAR_EQUALS_SIGN) || *ptr == CHAR_APOSTROPHE)
+       {
+       int term;
+       const uschar *thisname;
+       *count += 1;
+       if (name == NULL && *count == lorn) return *count;
+       term = *ptr++;
+       if (term == CHAR_LESS_THAN_SIGN) term = CHAR_GREATER_THAN_SIGN;
+       thisname = ptr;
+       while (*ptr != term) ptr++;
+       if (name != NULL && lorn == ptr - thisname &&
+           strncmp((const char *)name, (const char *)thisname, lorn) == 0)
+         return *count;
+       term++;
+       }
+     }
+   }
+ /* Past any initial parenthesis handling, scan for parentheses or vertical
+ bars. */
+ for (; *ptr != 0; ptr++)
+   {
    /* Skip over backslashed characters and also entire \Q...\E */
-   if (*ptr == '\\')
+   if (*ptr == CHAR_BACKSLASH)
      {
-     if (*(++ptr) == 0) return -1;
+     if (*(++ptr) == 0) goto FAIL_EXIT;
-     if (*ptr == 'Q') for (;;)
+     if (*ptr == CHAR_Q) for (;;)
        {
-       while (*(++ptr) != 0 && *ptr != '\\');
+       while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};
-       if (*ptr == 0) return -1;
+       if (*ptr == 0) goto FAIL_EXIT;
-       if (*(++ptr) == 'E') break;
+       if (*(++ptr) == CHAR_E) break;
        }
      continue;
      }
-   /* Skip over character classes */
+   /* Skip over character classes; this logic must be similar to the way they
+   are handled for real. If the first character is '^', skip it. Also, if the
+   first few characters (either before or after ^) are \Q\E or \E we skip them
+   too. This makes for compatibility with Perl. Note the use of STR macros to
+   encode "Q\\E" so that it works in UTF-8 on EBCDIC platforms. */
-   if (*ptr == '[')
+   if (*ptr == CHAR_LEFT_SQUARE_BRACKET)
      {
-     while (*(++ptr) != ']')
+     BOOL negate_class = FALSE;
+     for (;;)
+       {
+       if (ptr[1] == CHAR_BACKSLASH)
+         {
+         if (ptr[2] == CHAR_E)
+           ptr+= 2;
+         else if (strncmp((const char *)ptr+2,
+                  STR_Q STR_BACKSLASH STR_E, 3) == 0)
+           ptr += 4;
+         else
+           break;
+         }
+       else if (!negate_class && ptr[1] == CHAR_CIRCUMFLEX_ACCENT)
+         {
+         negate_class = TRUE;
+         ptr++;
+         }
+       else break;
+       }
+     /* If the next character is ']', it is a data character that must be
+     skipped, except in JavaScript compatibility mode. */
+     if (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET &&
+         (cd->external_options & PCRE_JAVASCRIPT_COMPAT) == 0)
+       ptr++;
+     while (*(++ptr) != CHAR_RIGHT_SQUARE_BRACKET)
        {
        if (*ptr == 0) return -1;
-       if (*ptr == '\\')
+       if (*ptr == CHAR_BACKSLASH)
          {
-         if (*(++ptr) == 0) return -1;
+         if (*(++ptr) == 0) goto FAIL_EXIT;
-         if (*ptr == 'Q') for (;;)
+         if (*ptr == CHAR_Q) for (;;)
            {
-           while (*(++ptr) != 0 && *ptr != '\\');
+           while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};
-           if (*ptr == 0) return -1;
+           if (*ptr == 0) goto FAIL_EXIT;
-           if (*(++ptr) == 'E') break;
+           if (*(++ptr) == CHAR_E) break;
            }
          continue;
          }
-Line 1008 
 for (; *ptr != 0; ptr++)
+Line 1195 
 for (; *ptr != 0; ptr++)
    /* Skip comments in /x mode */
-   if (xmode && *ptr == '#')
+   if (xmode && *ptr == CHAR_NUMBER_SIGN)
      {
-     while (*(++ptr) != 0 && *ptr != '\n');
+     while (*(++ptr) != 0 && *ptr != CHAR_NL) {};
-     if (*ptr == 0) return -1;
+     if (*ptr == 0) goto FAIL_EXIT;
      continue;
      }
-   /* An opening parens must now be a real metacharacter */
+   /* Check for the special metacharacters */
-   if (*ptr != '(') continue;
+   if (*ptr == CHAR_LEFT_PARENTHESIS)
-   if (ptr[1] != '?' && ptr[1] != '*')
      {
-     count++;
+     int rc = find_parens_sub(&ptr, cd, name, lorn, xmode, count);
-     if (name == NULL && count == lorn) return count;
+     if (rc > 0) return rc;
-     continue;
+     if (*ptr == 0) goto FAIL_EXIT;
      }
-   ptr += 2;
+   else if (*ptr == CHAR_RIGHT_PARENTHESIS)
-   if (*ptr == 'P') ptr++;                      /* Allow optional P */
+     {
+     if (dup_parens && *count < hwm_count) *count = hwm_count;
+     *ptrptr = ptr;
+     return -1;
+     }
-   /* We have to disambiguate (?<! and (?<= from (?<name> */
+   else if (*ptr == CHAR_VERTICAL_LINE && dup_parens)
+     {
+     if (*count > hwm_count) hwm_count = *count;
+     *count = start_count;
+     }
+   }
-   if ((*ptr != '<' || ptr[1] == '!' || ptr[1] == '=') &&
+ FAIL_EXIT:
-        *ptr != '\'')
+ *ptrptr = ptr;
-     continue;
+ return -1;
+ }
-   count++;
-   if (name == NULL && count == lorn) return count;
-   term = *ptr++;
-   if (term == '<') term = '>';
+ /*************************************************
-   thisname = ptr;
+ *       Find forward referenced subpattern       *
-   while (*ptr != term) ptr++;
+ *************************************************/
-   if (name != NULL && lorn == ptr - thisname &&
-       strncmp((const char *)name, (const char *)thisname, lorn) == 0)
+ /* This function scans along a pattern's text looking for capturing
-     return count;
+ subpatterns, and counting them. If it finds a named pattern that matches the
+ name it is given, it returns its number. Alternatively, if the name is NULL, it
+ returns when it reaches a given numbered subpattern. This is used for forward
+ references to subpatterns. We used to be able to start this scan from the
+ current compiling point, using the current count value from cd->bracount, and
+ do it all in a single loop, but the addition of the possibility of duplicate
+ subpattern numbers means that we have to scan from the very start, in order to
+ take account of such duplicates, and to use a recursive function to keep track
+ of the different types of group.
+ Arguments:
+   cd           compile background data
+   name         name to seek, or NULL if seeking a numbered subpattern
+   lorn         name length, or subpattern number if name is NULL
+   xmode        TRUE if we are in /x mode
+ Returns:       the number of the found subpattern, or -1 if not found
+ */
+ static int
+ find_parens(compile_data *cd, const uschar *name, int lorn, BOOL xmode)
+ {
+ uschar *ptr = (uschar *)cd->start_pattern;
+ int count = 0;
+ int rc;
+ /* If the pattern does not start with an opening parenthesis, the first call
+ to find_parens_sub() will scan right to the end (if necessary). However, if it
+ does start with a parenthesis, find_parens_sub() will return when it hits the
+ matching closing parens. That is why we have to have a loop. */
+ for (;;)
+   {
+   rc = find_parens_sub(&ptr, cd, name, lorn, xmode, &count);
+   if (rc > 0 || *ptr++ == 0) break;
    }
- return -1;
+ return rc;
  }
  /*************************************************
  *      Find first significant op code            *
  *************************************************/
-Line 1100 
 for (;;)
+Line 1330 
 for (;;)
      case OP_CALLOUT:
      case OP_CREF:
+     case OP_NCREF:
      case OP_RREF:
+     case OP_NRREF:
      case OP_DEF:
      code += _pcre_OP_lengths[*code];
      break;
-Line 1116 
 for (;;)
+Line 1348 
 for (;;)
  /*************************************************
- *        Find the fixed length of a pattern      *
+ *        Find the fixed length of a branch       *
  *************************************************/
- /* Scan a pattern and compute the fixed length of subject that will match it,
+ /* Scan a branch and compute the fixed length of subject that will match it,
  if the length is fixed. This is needed for dealing with backward assertions.
- In UTF8 mode, the result is in characters rather than bytes.
+ In UTF8 mode, the result is in characters rather than bytes. The branch is
+ temporarily terminated with OP_END when this function is called.
+ This function is called when a backward assertion is encountered, so that if it
+ fails, the error message can point to the correct place in the pattern.
+ However, we cannot do this when the assertion contains subroutine calls,
+ because they can be forward references. We solve this by remembering this case
+ and doing the check at the end; a flag specifies which mode we are running in.
  Arguments:
    code     points to the start of the pattern (the bracket)
    options  the compiling options
+   atend    TRUE if called when the pattern is complete
+   cd       the "compile data" structure
- Returns:   the fixed length, or -1 if there is no fixed length,
+ Returns:   the fixed length,
+              or -1 if there is no fixed length,
               or -2 if \C was encountered
+              or -3 if an OP_RECURSE item was encountered and atend is FALSE
  */
  static int
- find_fixedlength(uschar *code, int options)
+ find_fixedlength(uschar *code, int options, BOOL atend, compile_data *cd)
  {
  int length = -1;
-Line 1145 
 branch, check the length against that of
+Line 1388 
 branch, check the length against that of
  for (;;)
    {
    int d;
+   uschar *ce, *cs;
    register int op = *cc;
    switch (op)
      {
-Line 1152 
 for (;;)
+Line 1396 
 for (;;)
      case OP_BRA:
      case OP_ONCE:
      case OP_COND:
-     d = find_fixedlength(cc + ((op == OP_CBRA)? 2:0), options);
+     d = find_fixedlength(cc + ((op == OP_CBRA)? 2:0), options, atend, cd);
      if (d < 0) return d;
      branchlength += d;
      do cc += GET(cc, 1); while (*cc == OP_ALT);
-Line 1175 
 for (;;)
+Line 1419 
 for (;;)
      branchlength = 0;
      break;
+     /* A true recursion implies not fixed length, but a subroutine call may
+     be OK. If the subroutine is a forward reference, we can't deal with
+     it until the end of the pattern, so return -3. */
+     case OP_RECURSE:
+     if (!atend) return -3;
+     cs = ce = (uschar *)cd->start_code + GET(cc, 1);  /* Start subpattern */
+     do ce += GET(ce, 1); while (*ce == OP_ALT);       /* End subpattern */
+     if (cc > cs && cc < ce) return -1;                /* Recursion */
+     d = find_fixedlength(cs + 2, options, atend, cd);
+     if (d < 0) return d;
+     branchlength += d;
+     cc += 1 + LINK_SIZE;
+     break;
      /* Skip over assertive subpatterns */
      case OP_ASSERT:
-Line 1188 
 for (;;)
+Line 1447 
 for (;;)
      case OP_REVERSE:
      case OP_CREF:
+     case OP_NCREF:
      case OP_RREF:
+     case OP_NRREF:
      case OP_DEF:
      case OP_OPT:
      case OP_CALLOUT:
      case OP_SOD:
      case OP_SOM:
+     case OP_SET_SOM:
      case OP_EOD:
      case OP_EODN:
      case OP_CIRC:
-Line 1211 
 for (;;)
+Line 1473 
 for (;;)
      branchlength++;
      cc += 2;
  #ifdef SUPPORT_UTF8
-     if ((options & PCRE_UTF8) != 0)
+     if ((options & PCRE_UTF8) != 0 && cc[-1] >= 0xc0)
-       {
+       cc += _pcre_utf8_table4[cc[-1] & 0x3f];
-       while ((*cc & 0xc0) == 0x80) cc++;
-       }
  #endif
      break;
-Line 1225 
 for (;;)
+Line 1485 
 for (;;)
      branchlength += GET2(cc,1);
      cc += 4;
  #ifdef SUPPORT_UTF8
-     if ((options & PCRE_UTF8) != 0)
+     if ((options & PCRE_UTF8) != 0 && cc[-1] >= 0xc0)
-       {
+       cc += _pcre_utf8_table4[cc[-1] & 0x3f];
-       while((*cc & 0x80) == 0x80) cc++;
-       }
  #endif
      break;
-Line 1252 
 for (;;)
+Line 1510 
 for (;;)
      case OP_NOT_WORDCHAR:
      case OP_WORDCHAR:
      case OP_ANY:
+     case OP_ALLANY:
      branchlength++;
      cc++;
      break;
-Line 1306 
 for (;;)
+Line 1565 
 for (;;)
  /*************************************************
- *    Scan compiled regex for numbered bracket    *
+ *    Scan compiled regex for specific bracket    *
  *************************************************/
  /* This little function scans through a compiled pattern until it finds a
- capturing bracket with the given number.
+ capturing bracket with the given number, or, if the number is negative, an
+ instance of OP_REVERSE for a lookbehind. The function is global in the C sense
+ so that it can be called from pcre_study() when finding the minimum matching
+ length.
  Arguments:
    code        points to start of expression
    utf8        TRUE in UTF-8 mode
-   number      the required bracket number
+   number      the required bracket number or negative to find a lookbehind
  Returns:      pointer to the opcode for the bracket, or NULL if not found
  */
- static const uschar *
+ const uschar *
- find_bracket(const uschar *code, BOOL utf8, int number)
+ _pcre_find_bracket(const uschar *code, BOOL utf8, int number)
  {
  for (;;)
    {
-Line 1334 
 for (;;)
+Line 1596 
 for (;;)
    if (c == OP_XCLASS) code += GET(code, 1);
+   /* Handle recursion */
+   else if (c == OP_REVERSE)
+     {
+     if (number < 0) return (uschar *)code;
+     code += _pcre_OP_lengths[c];
+     }
    /* Handle capturing bracket */
    else if (c == OP_CBRA)
-Line 1400 
 for (;;)
+Line 1670 
 for (;;)
        if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
        break;
        }
+ #else
+     (void)(utf8);  /* Keep compiler happy by referencing function argument */
  #endif
      }
    }
-Line 1493 
 for (;;)
+Line 1765 
 for (;;)
        if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
        break;
        }
+ #else
+     (void)(utf8);  /* Keep compiler happy by referencing function argument */
  #endif
      }
    }
-Line 1508 
 for (;;)
+Line 1782 
 for (;;)
  can match the empty string or not. It is called from could_be_empty()
  below and from compile_branch() when checking for an unlimited repeat of a
  group that can match nothing. Note that first_significant_code() skips over
- assertions. If we hit an unclosed bracket, we return "empty" - this means we've
+ backward and negative forward assertions when its final argument is TRUE. If we
- struck an inner bracket whose current branch will already have been scanned.
+ hit an unclosed bracket, we return "empty" - this means we've struck an inner
+ bracket whose current branch will already have been scanned.
  Arguments:
    code        points to start of search
    endcode     points to where to stop
    utf8        TRUE if in UTF8 mode
+   cd          contains pointers to tables etc.
  Returns:      TRUE if what is matched could be empty
  */
  static BOOL
- could_be_empty_branch(const uschar *code, const uschar *endcode, BOOL utf8)
+ could_be_empty_branch(const uschar *code, const uschar *endcode, BOOL utf8,
+   compile_data *cd)
  {
  register int c;
  for (code = first_significant_code(code + _pcre_OP_lengths[*code], NULL, 0, TRUE);
-Line 1531 
 for (code = first_significant_code(code
+Line 1808 
 for (code = first_significant_code(code
    c = *code;
+   /* Skip over forward assertions; the other assertions are skipped by
+   first_significant_code() with a TRUE final argument. */
+   if (c == OP_ASSERT)
+     {
+     do code += GET(code, 1); while (*code == OP_ALT);
+     c = *code;
+     continue;
+     }
    /* Groups with zero repeats can of course be empty; skip them. */
-   if (c == OP_BRAZERO || c == OP_BRAMINZERO)
+   if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO)
      {
      code += _pcre_OP_lengths[c];
      do code += GET(code, 1); while (*code == OP_ALT);
-Line 1541 
 for (code = first_significant_code(code
+Line 1828 
 for (code = first_significant_code(code
      continue;
      }
+   /* For a recursion/subroutine call, if its end has been reached, which
+   implies a subroutine call, we can scan it. */
+   if (c == OP_RECURSE)
+     {
+     BOOL empty_branch = FALSE;
+     const uschar *scode = cd->start_code + GET(code, 1);
+     if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
+     do
+       {
+       if (could_be_empty_branch(scode, endcode, utf8, cd))
+         {
+         empty_branch = TRUE;
+         break;
+         }
+       scode += GET(scode, 1);
+       }
+     while (*scode == OP_ALT);
+     if (!empty_branch) return FALSE;  /* All branches are non-empty */
+     continue;
+     }
    /* For other groups, scan the branches. */
    if (c == OP_BRA || c == OP_CBRA || c == OP_ONCE || c == OP_COND)
-Line 1548 
 for (code = first_significant_code(code
+Line 1857 
 for (code = first_significant_code(code
      BOOL empty_branch;
      if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */
-     /* Scan a closed bracket */
+     /* If a conditional group has only one branch, there is a second, implied,
+     empty branch, so just skip over the conditional, because it could be empty.
+     Otherwise, scan the individual branches of the group. */
-     empty_branch = FALSE;
+     if (c == OP_COND && code[GET(code, 1)] != OP_ALT)
-     do
-       {
-       if (!empty_branch && could_be_empty_branch(code, endcode, utf8))
-         empty_branch = TRUE;
        code += GET(code, 1);
+     else
+       {
+       empty_branch = FALSE;
+       do
+         {
+         if (!empty_branch && could_be_empty_branch(code, endcode, utf8, cd))
+           empty_branch = TRUE;
+         code += GET(code, 1);
+         }
+       while (*code == OP_ALT);
+       if (!empty_branch) return FALSE;   /* All branches are non-empty */
        }
-     while (*code == OP_ALT);
-     if (!empty_branch) return FALSE;   /* All branches are non-empty */
      c = *code;
      continue;
      }
-Line 1619 
 for (code = first_significant_code(code
+Line 1936 
 for (code = first_significant_code(code
      case OP_NOT_WORDCHAR:
      case OP_WORDCHAR:
      case OP_ANY:
+     case OP_ALLANY:
      case OP_ANYBYTE:
      case OP_CHAR:
      case OP_CHARNC:
-Line 1675 
 for (code = first_significant_code(code
+Line 1993 
 for (code = first_significant_code(code
      case OP_QUERY:
      case OP_MINQUERY:
      case OP_POSQUERY:
+     if (utf8 && code[1] >= 0xc0) code += _pcre_utf8_table4[code[1] & 0x3f];
+     break;
      case OP_UPTO:
      case OP_MINUPTO:
      case OP_POSUPTO:
-     if (utf8) while ((code[2] & 0xc0) == 0x80) code++;
+     if (utf8 && code[3] >= 0xc0) code += _pcre_utf8_table4[code[3] & 0x3f];
      break;
  #endif
+     /* None of the remaining opcodes are required to match a character. */
+     default:
+     break;
      }
    }
-Line 1703 
 Arguments:
+Line 2029 
 Arguments:
    endcode     points to where to stop (current RECURSE item)
    bcptr       points to the chain of current (unclosed) branch starts
    utf8        TRUE if in UTF-8 mode
+   cd          pointers to tables etc
  Returns:      TRUE if what is matched could be empty
  */
  static BOOL
  could_be_empty(const uschar *code, const uschar *endcode, branch_chain *bcptr,
-   BOOL utf8)
+   BOOL utf8, compile_data *cd)
  {
- while (bcptr != NULL && bcptr->current >= code)
+ while (bcptr != NULL && bcptr->current_branch >= code)
    {
-   if (!could_be_empty_branch(bcptr->current, endcode, utf8)) return FALSE;
+   if (!could_be_empty_branch(bcptr->current_branch, endcode, utf8, cd))
+     return FALSE;
    bcptr = bcptr->outer;
    }
  return TRUE;
-Line 1726 
 return TRUE;
+Line 2054 
 return TRUE;
  *************************************************/
  /* This function is called when the sequence "[:" or "[." or "[=" is
- encountered in a character class. It checks whether this is followed by an
+ encountered in a character class. It checks whether this is followed by a
- optional ^ and then a sequence of letters, terminated by a matching ":]" or
+ sequence of characters terminated by a matching ":]" or ".]" or "=]". If we
- ".]" or "=]".
+ 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.
- Argument:
+ Arguments:
    ptr      pointer to the initial [
    endptr   where to return the end pointer
-   cd       pointer to compile data
  Returns:   TRUE or FALSE
  */
  static BOOL
- check_posix_syntax(const uschar *ptr, const uschar **endptr, compile_data *cd)
+ check_posix_syntax(const uschar *ptr, const uschar **endptr)
  {
  int terminator;          /* Don't combine these lines; the Solaris cc */
  terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
- if (*(++ptr) == '^') ptr++;
+ for (++ptr; *ptr != 0; ptr++)
- while ((cd->ctypes[*ptr] & ctype_letter) != 0) ptr++;
- if (*ptr == terminator && ptr[1] == ']')
    {
-   *endptr = ptr;
+   if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET) ptr++; else
-   return TRUE;
+     {
+     if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
+     if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
+       {
+       *endptr = ptr;
+       return TRUE;
+       }
+     }
    }
  return FALSE;
  }
-Line 1794 
 return -1;
+Line 2141 
 return -1;
  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 is inserted before
+ optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is
- it, after it has been compiled. This means that any OP_RECURSE items within it
+ inserted before it, after it has been compiled. This means that any OP_RECURSE
- that refer to the group itself or any contained groups have to have their
+ items within it that refer to the group itself or any contained groups have to
- offsets adjusted. That one of the jobs of this function. Before it is called,
+ have their offsets adjusted. That one of the jobs of this function. Before it
- the partially compiled regex must be temporarily terminated with OP_END.
+ 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
-Line 1933 
 get_othercase_range(unsigned int *cptr,
+Line 2281 
 get_othercase_range(unsigned int *cptr,
  unsigned int c, othercase, next;
  for (c = *cptr; c <= d; c++)
-   { if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR) break; }
+   { if ((othercase = UCD_OTHERCASE(c)) != c) break; }
  if (c > d) return FALSE;
-Line 1942 
 next = othercase + 1;
+Line 2290 
 next = othercase + 1;
  for (++c; c <= d; c++)
    {
-   if (_pcre_ucp_othercase(c) != next) break;
+   if (UCD_OTHERCASE(c) != next) break;
    next++;
    }
-Line 1988 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2336 
 if ((options & PCRE_EXTENDED) != 0)
    for (;;)
      {
      while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
-     if (*ptr == '#')
+     if (*ptr == CHAR_NUMBER_SIGN)
        {
        while (*(++ptr) != 0)
          if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
-Line 2000 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2348 
 if ((options & PCRE_EXTENDED) != 0)
  /* If the next item is one that we can handle, get its value. A non-negative
  value is a character, a negative value is an escape value. */
- if (*ptr == '\\')
+ if (*ptr == CHAR_BACKSLASH)
    {
    int temperrorcode = 0;
    next = check_escape(&ptr, &temperrorcode, cd->bracount, options, FALSE);
-Line 2025 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2373 
 if ((options & PCRE_EXTENDED) != 0)
    for (;;)
      {
      while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
-     if (*ptr == '#')
+     if (*ptr == CHAR_NUMBER_SIGN)
        {
        while (*(++ptr) != 0)
          if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
-Line 2036 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2384 
 if ((options & PCRE_EXTENDED) != 0)
  /* If the next thing is itself optional, we have to give up. */
- if (*ptr == '*' || *ptr == '?' || strncmp((char *)ptr, "{0,", 3) == 0)
+ if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||
-   return FALSE;
+   strncmp((char *)ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
+     return FALSE;
  /* Now compare the next item with the previous opcode. If the previous is a
  positive single character match, "item" either contains the character or, if
-Line 2052 
 if (next >= 0) switch(op_code)
+Line 2401 
 if (next >= 0) switch(op_code)
    case OP_CHAR:
  #ifdef SUPPORT_UTF8
    if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
+ #else
+   (void)(utf8_char);  /* Keep compiler happy by referencing function argument */
  #endif
    return item != next;
-Line 2070 
 if (next >= 0) switch(op_code)
+Line 2421 
 if (next >= 0) switch(op_code)
      unsigned int othercase;
      if (next < 128) othercase = cd->fcc[next]; else
  #ifdef SUPPORT_UCP
-     othercase = _pcre_ucp_othercase((unsigned int)next);
+     othercase = UCD_OTHERCASE((unsigned int)next);
  #else
      othercase = NOTACHAR;
  #endif
-Line 2083 
 if (next >= 0) switch(op_code)
+Line 2434 
 if (next >= 0) switch(op_code)
    /* For OP_NOT, "item" must be a single-byte character. */
    case OP_NOT:
-   if (next < 0) return FALSE;  /* Not a character */
    if (item == next) return TRUE;
    if ((options & PCRE_CASELESS) == 0) return FALSE;
  #ifdef SUPPORT_UTF8
-Line 2092 
 if (next >= 0) switch(op_code)
+Line 2442 
 if (next >= 0) switch(op_code)
      unsigned int othercase;
      if (next < 128) othercase = cd->fcc[next]; else
  #ifdef SUPPORT_UCP
-     othercase = _pcre_ucp_othercase(next);
+     othercase = UCD_OTHERCASE(next);
  #else
      othercase = NOTACHAR;
  #endif
-Line 2346 
 uschar classbits[32];
+Line 2696 
 uschar classbits[32];
  BOOL class_utf8;
  BOOL utf8 = (options & PCRE_UTF8) != 0;
  uschar *class_utf8data;
+ uschar *class_utf8data_base;
  uschar utf8_char[6];
  #else
  BOOL utf8 = FALSE;
  uschar *utf8_char = NULL;
  #endif
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  if (lengthptr != NULL) DPRINTF((">> start branch\n"));
  #endif
-Line 2385 
 req_caseopt = ((options & PCRE_CASELESS)
+Line 2736 
 req_caseopt = ((options & PCRE_CASELESS)
  for (;; ptr++)
    {
    BOOL negate_class;
    BOOL should_flip_negation;
    BOOL possessive_quantifier;
    BOOL is_quantifier;
    BOOL is_recurse;
-Line 2411 
 for (;; ptr++)
+Line 2762 
 for (;; ptr++)
    if (lengthptr != NULL)
      {
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
      if (code > cd->hwm) cd->hwm = code;                 /* High water info */
  #endif
-     if (code > cd->start_workspace + COMPILE_WORK_SIZE) /* Check for overrun */
+     if (code > cd->start_workspace + WORK_SIZE_CHECK)   /* Check for overrun */
        {
        *errorcodeptr = ERR52;
        goto FAILED;
-Line 2463 
 for (;; ptr++)
+Line 2814 
 for (;; ptr++)
    /* In the real compile phase, just check the workspace used by the forward
    reference list. */
-   else if (cd->hwm > cd->start_workspace + COMPILE_WORK_SIZE)
+   else if (cd->hwm > cd->start_workspace + WORK_SIZE_CHECK)
      {
      *errorcodeptr = ERR52;
      goto FAILED;
-Line 2473 
 for (;; ptr++)
+Line 2824 
 for (;; ptr++)
    if (inescq && c != 0)
      {
-     if (c == '\\' && ptr[1] == 'E')
+     if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)
        {
        inescq = FALSE;
        ptr++;
-Line 2499 
 for (;; ptr++)
+Line 2850 
 for (;; ptr++)
    /* Fill in length of a previous callout, except when the next thing is
    a quantifier. */
-   is_quantifier = c == '*' || c == '+' || c == '?' ||
+   is_quantifier =
-     (c == '{' && is_counted_repeat(ptr+1));
+     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)
-Line 2515 
 for (;; ptr++)
+Line 2867 
 for (;; ptr++)
    if ((options & PCRE_EXTENDED) != 0)
      {
      if ((cd->ctypes[c] & ctype_space) != 0) continue;
-     if (c == '#')
+     if (c == CHAR_NUMBER_SIGN)
        {
        while (*(++ptr) != 0)
          {
-Line 2540 
 for (;; ptr++)
+Line 2892 
 for (;; ptr++)
      {
      /* ===================================================================*/
      case 0:                        /* The branch terminates at string end */
-     case '|':                      /* or | or ) */
+     case CHAR_VERTICAL_LINE:       /* or | or ) */
-     case ')':
+     case CHAR_RIGHT_PARENTHESIS:
      *firstbyteptr = firstbyte;
      *reqbyteptr = reqbyte;
      *codeptr = code;
-Line 2563 
 for (;; ptr++)
+Line 2915 
 for (;; ptr++)
      /* Handle single-character metacharacters. In multiline mode, ^ disables
      the setting of any following char as a first character. */
-     case '^':
+     case CHAR_CIRCUMFLEX_ACCENT:
      if ((options & PCRE_MULTILINE) != 0)
        {
        if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
-Line 2572 
 for (;; ptr++)
+Line 2924 
 for (;; ptr++)
      *code++ = OP_CIRC;
      break;
-     case '$':
+     case CHAR_DOLLAR_SIGN:
      previous = NULL;
      *code++ = OP_DOLL;
      break;
-Line 2580 
 for (;; ptr++)
+Line 2932 
 for (;; ptr++)
      /* There can never be a first char if '.' is first, whatever happens about
      repeats. The value of reqbyte doesn't change either. */
-     case '.':
+     case CHAR_DOT:
      if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
      zerofirstbyte = firstbyte;
      zeroreqbyte = reqbyte;
      previous = code;
-     *code++ = OP_ANY;
+     *code++ = ((options & PCRE_DOTALL) != 0)? OP_ALLANY: OP_ANY;
      break;
-Line 2600 
 for (;; ptr++)
+Line 2952 
 for (;; ptr++)
      opcode is compiled. It may optionally have a bit map for characters < 256,
      but those above are are explicitly listed afterwards. A flag byte tells
      whether the bitmap is present, and whether this is a negated class or not.
-     */
-     case '[':
+     In JavaScript compatibility mode, an isolated ']' causes an error. In
+     default (Perl) mode, it is treated as a data character. */
+     case CHAR_RIGHT_SQUARE_BRACKET:
+     if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
+       {
+       *errorcodeptr = ERR64;
+       goto FAILED;
+       }
+     goto NORMAL_CHAR;
+     case CHAR_LEFT_SQUARE_BRACKET:
      previous = code;
      /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
      they are encountered at the top level, so we'll do that too. */
-     if ((ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
+     if ((ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
-         check_posix_syntax(ptr, &tempptr, cd))
+          ptr[1] == CHAR_EQUALS_SIGN) &&
+         check_posix_syntax(ptr, &tempptr))
        {
-       *errorcodeptr = (ptr[1] == ':')? ERR13 : ERR31;
+       *errorcodeptr = (ptr[1] == CHAR_COLON)? ERR13 : ERR31;
        goto FAILED;
        }
-Line 2623 
 for (;; ptr++)
+Line 2986 
 for (;; ptr++)
      for (;;)
        {
        c = *(++ptr);
-       if (c == '\\')
+       if (c == CHAR_BACKSLASH)
          {
-         if (ptr[1] == 'E') ptr++;
+         if (ptr[1] == CHAR_E)
-           else if (strncmp((const char *)ptr+1, "Q\\E", 3) == 0) ptr += 3;
+           ptr++;
-             else break;
+         else if (strncmp((const char *)ptr+1,
+                           STR_Q STR_BACKSLASH STR_E, 3) == 0)
+           ptr += 3;
+         else
+           break;
          }
-       else if (!negate_class && c == '^')
+       else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT)
          negate_class = TRUE;
        else break;
        }
-     /* If a class contains a negative special such as \S, we need to flip the
+     /* Empty classes are allowed in JavaScript compatibility mode. Otherwise,
-     negation flag at the end, so that support for characters > 255 works
+     an initial ']' is taken as a data character -- the code below handles
+     that. In JS mode, [] must always fail, so generate OP_FAIL, whereas
+     [^] must match any character, so generate OP_ALLANY. */
+     if (c == CHAR_RIGHT_SQUARE_BRACKET &&
+         (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
+       {
+       *code++ = negate_class? OP_ALLANY : OP_FAIL;
+       if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
+       zerofirstbyte = firstbyte;
+       break;
+       }
+     /* If a class contains a negative special such as \S, we need to flip the
+     negation flag at the end, so that support for characters > 255 works
      correctly (they are all included in the class). */
      should_flip_negation = FALSE;
-Line 2657 
 for (;; ptr++)
+Line 3038 
 for (;; ptr++)
  #ifdef SUPPORT_UTF8
      class_utf8 = FALSE;                       /* No chars >= 256 */
      class_utf8data = code + LINK_SIZE + 2;    /* For UTF-8 items */
+     class_utf8data_base = class_utf8data;     /* For resetting in pass 1 */
  #endif
      /* Process characters until ] is reached. By writing this as a "do" it
-Line 2672 
 for (;; ptr++)
+Line 3054 
 for (;; ptr++)
          {                           /* Braces are required because the */
          GETCHARLEN(c, ptr, ptr);    /* macro generates multiple statements */
          }
+       /* In the pre-compile phase, accumulate the length of any UTF-8 extra
+       data and reset the pointer. This is so that very large classes that
+       contain a zillion UTF-8 characters no longer overwrite the work space
+       (which is on the stack). */
+       if (lengthptr != NULL)
+         {
+         *lengthptr += class_utf8data - class_utf8data_base;
+         class_utf8data = class_utf8data_base;
+         }
  #endif
        /* Inside \Q...\E everything is literal except \E */
        if (inescq)
          {
-         if (c == '\\' && ptr[1] == 'E')     /* If we are at \E */
+         if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)  /* If we are at \E */
            {
            inescq = FALSE;                   /* Reset literal state */
            ptr++;                            /* Skip the 'E' */
-Line 2693 
 for (;; ptr++)
+Line 3087 
 for (;; ptr++)
        [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
 .6 and 5.8 do. */
-       if (c == '[' &&
+       if (c == CHAR_LEFT_SQUARE_BRACKET &&
-           (ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
+           (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
-           check_posix_syntax(ptr, &tempptr, cd))
+            ptr[1] == CHAR_EQUALS_SIGN) && check_posix_syntax(ptr, &tempptr))
          {
          BOOL local_negate = FALSE;
          int posix_class, taboffset, tabopt;
          register const uschar *cbits = cd->cbits;
          uschar pbits[32];
-         if (ptr[1] != ':')
+         if (ptr[1] != CHAR_COLON)
            {
            *errorcodeptr = ERR31;
            goto FAILED;
            }
          ptr += 2;
-         if (*ptr == '^')
+         if (*ptr == CHAR_CIRCUMFLEX_ACCENT)
            {
            local_negate = TRUE;
            should_flip_negation = TRUE;  /* Note negative special */
            ptr++;
            }
-Line 2782 
 for (;; ptr++)
+Line 3176 
 for (;; ptr++)
        to 'or' into the one we are building. We assume they have more than one
        character in them, so set class_charcount bigger than one. */
-       if (c == '\\')
+       if (c == CHAR_BACKSLASH)
          {
          c = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
          if (*errorcodeptr != 0) goto FAILED;
-         if (-c == ESC_b) c = '\b';       /* \b is backspace in a class */
+         if (-c == ESC_b) c = CHAR_BS;       /* \b is backspace in a class */
-         else if (-c == ESC_X) c = 'X';   /* \X is literal X in a class */
+         else if (-c == ESC_X) c = CHAR_X;   /* \X is literal X in a class */
-         else if (-c == ESC_R) c = 'R';   /* \R is literal R in a class */
+         else if (-c == ESC_R) c = CHAR_R;   /* \R is literal R in a class */
          else if (-c == ESC_Q)            /* Handle start of quoted string */
            {
-           if (ptr[1] == '\\' && ptr[2] == 'E')
+           if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
              {
              ptr += 2; /* avoid empty string */
              }
-Line 2815 
 for (;; ptr++)
+Line 3209 
 for (;; ptr++)
              continue;
              case ESC_D:
              should_flip_negation = TRUE;
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
              continue;
-Line 2824 
 for (;; ptr++)
+Line 3218 
 for (;; ptr++)
              continue;
              case ESC_W:
              should_flip_negation = TRUE;
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
              continue;
-Line 2834 
 for (;; ptr++)
+Line 3228 
 for (;; ptr++)
              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;
-             case ESC_E: /* Perl ignores an orphan \E */
-             continue;
              default:    /* Not recognized; fall through */
              break;      /* Need "default" setting to stop compiler warning. */
              }
-Line 3021 
 for (;; ptr++)
+Line 3412 
 for (;; ptr++)
        entirely. The code for handling \Q and \E is messy. */
        CHECK_RANGE:
-       while (ptr[1] == '\\' && ptr[2] == 'E')
+       while (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
          {
          inescq = FALSE;
          ptr += 2;
-Line 3031 
 for (;; ptr++)
+Line 3422 
 for (;; ptr++)
        /* Remember \r or \n */
-       if (c == '\r' || c == '\n') cd->external_flags |= PCRE_HASCRORLF;
+       if (c == CHAR_CR || c == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;
        /* Check for range */
-       if (!inescq && ptr[1] == '-')
+       if (!inescq && ptr[1] == CHAR_MINUS)
          {
          int d;
          ptr += 2;
-         while (*ptr == '\\' && ptr[1] == 'E') ptr += 2;
+         while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E) ptr += 2;
          /* If we hit \Q (not followed by \E) at this point, go into escaped
          mode. */
-         while (*ptr == '\\' && ptr[1] == 'Q')
+         while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_Q)
            {
            ptr += 2;
-           if (*ptr == '\\' && ptr[1] == 'E') { ptr += 2; continue; }
+           if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E)
+             { ptr += 2; continue; }
            inescq = TRUE;
            break;
            }
-         if (*ptr == 0 || (!inescq && *ptr == ']'))
+         if (*ptr == 0 || (!inescq && *ptr == CHAR_RIGHT_SQUARE_BRACKET))
            {
            ptr = oldptr;
            goto LONE_SINGLE_CHARACTER;
-Line 3071 
 for (;; ptr++)
+Line 3463 
 for (;; ptr++)
          not any of the other escapes. Perl 5.6 treats a hyphen as a literal
          in such circumstances. */
-         if (!inescq && d == '\\')
+         if (!inescq && d == CHAR_BACKSLASH)
            {
            d = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
            if (*errorcodeptr != 0) goto FAILED;
-Line 3081 
 for (;; ptr++)
+Line 3473 
 for (;; ptr++)
            if (d < 0)
              {
-             if (d == -ESC_b) d = '\b';
+             if (d == -ESC_b) d = CHAR_BS;
-             else if (d == -ESC_X) d = 'X';
+             else if (d == -ESC_X) d = CHAR_X;
-             else if (d == -ESC_R) d = 'R'; else
+             else if (d == -ESC_R) d = CHAR_R; else
                {
                ptr = oldptr;
                goto LONE_SINGLE_CHARACTER;  /* A few lines below */
-Line 3104 
 for (;; ptr++)
+Line 3496 
 for (;; ptr++)
          /* Remember \r or \n */
-         if (d == '\r' || d == '\n') cd->external_flags |= PCRE_HASCRORLF;
+         if (d == CHAR_CR || d == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;
          /* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless
          matching, we have to use an XCLASS with extra data items. Caseless
-Line 3224 
 for (;; ptr++)
+Line 3616 
 for (;; ptr++)
          if ((options & PCRE_CASELESS) != 0)
            {
            unsigned int othercase;
-           if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR)
+           if ((othercase = UCD_OTHERCASE(c)) != c)
              {
              *class_utf8data++ = XCL_SINGLE;
              class_utf8data += _pcre_ord2utf8(othercase, class_utf8data);
-Line 3251 
 for (;; ptr++)
+Line 3643 
 for (;; ptr++)
      /* Loop until ']' reached. This "while" is the end of the "do" above. */
-     while ((c = *(++ptr)) != 0 && (c != ']' || inescq));
+     while ((c = *(++ptr)) != 0 && (c != CHAR_RIGHT_SQUARE_BRACKET || inescq));
      if (c == 0)                          /* Missing terminating ']' */
        {
-Line 3340 
 we set the flag only if there is a liter
+Line 3732 
 we set the flag only if there is a liter
      zeroreqbyte = reqbyte;
      /* If there are characters with values > 255, we have to compile an
      extended class, with its own opcode, unless there was a negated special
      such as \S in the class, because in that case all characters > 255 are in
      the class, so any that were explicitly given as well can be ignored. If
      (when there are explicit characters > 255 that must be listed) there are no
      characters < 256, we can omit the bitmap in the actual compiled code. */
-Line 3373 
 we set the flag only if there is a liter
+Line 3765 
 we set the flag only if there is a liter
        }
  #endif
      /* If there are no characters > 255, 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 in the class. Then copy the 32-byte
      map into the code vector, negating it if necessary. */
      *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
      if (negate_class)
        {
-Line 3396 
 we set the flag only if there is a liter
+Line 3788 
 we set the flag only if there is a liter
      /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
      has been tested above. */
-     case '{':
+     case CHAR_LEFT_CURLY_BRACKET:
      if (!is_quantifier) goto NORMAL_CHAR;
      ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);
      if (*errorcodeptr != 0) goto FAILED;
      goto REPEAT;
-     case '*':
+     case CHAR_ASTERISK:
      repeat_min = 0;
      repeat_max = -1;
      goto REPEAT;
-     case '+':
+     case CHAR_PLUS:
      repeat_min = 1;
      repeat_max = -1;
      goto REPEAT;
-     case '?':
+     case CHAR_QUESTION_MARK:
      repeat_min = 0;
      repeat_max = 1;
-Line 3447 
 we set the flag only if there is a liter
+Line 3839 
 we set the flag only if there is a liter
      but if PCRE_UNGREEDY is set, it works the other way round. We change the
      repeat type to the non-default. */
-     if (ptr[1] == '+')
+     if (ptr[1] == CHAR_PLUS)
        {
        repeat_type = 0;                  /* Force greedy */
        possessive_quantifier = TRUE;
        ptr++;
        }
-     else if (ptr[1] == '?')
+     else if (ptr[1] == CHAR_QUESTION_MARK)
        {
        repeat_type = greedy_non_default;
        ptr++;
-Line 3568 
 we set the flag only if there is a liter
+Line 3960 
 we set the flag only if there is a liter
        if (repeat_max == 0) goto END_REPEAT;
+       /*--------------------------------------------------------------------*/
+       /* This code is obsolete from release 8.00; the restriction was finally
+       removed: */
        /* All real repeats make it impossible to handle partial matching (maybe
        one day we will be able to remove this restriction). */
-       if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL;
+       /* if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL; */
+       /*--------------------------------------------------------------------*/
        /* Combine the op_type with the repeat_type */
-Line 3718 
 we set the flag only if there is a liter
+Line 4115 
 we set the flag only if there is a liter
          goto END_REPEAT;
          }
+       /*--------------------------------------------------------------------*/
+       /* This code is obsolete from release 8.00; the restriction was finally
+       removed: */
        /* All real repeats make it impossible to handle partial matching (maybe
        one day we will be able to remove this restriction). */
-       if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL;
+       /* if (repeat_max != 1) cd->external_flags |= PCRE_NOPARTIAL; */
+       /*--------------------------------------------------------------------*/
        if (repeat_min == 0 && repeat_max == -1)
          *code++ = OP_CRSTAR + repeat_type;
-Line 3779 
 we set the flag only if there is a liter
+Line 4181 
 we set the flag only if there is a liter
        if (repeat_min == 0)
          {
-         /* If the maximum is also zero, we just omit the group from the output
+         /* If the maximum is also zero, we used to just omit the group from the
-         altogether. */
+         output altogether, like this:
-         if (repeat_max == 0)
-           {
-           code = previous;
-           goto END_REPEAT;
-           }
-         /* If the maximum is 1 or unlimited, we just have to stick in the
+         ** if (repeat_max == 0)
-         BRAZERO and do no more at this point. However, we do need to adjust
+         **   {
-         any OP_RECURSE calls inside the group that refer to the group itself or
+         **   code = previous;
-         any internal or forward referenced group, because the offset is from
+         **   goto END_REPEAT;
-         the start of the whole regex. Temporarily terminate the pattern while
+         **   }
-         doing this. */
+         However, that fails when a group is referenced as a subroutine from
+         elsewhere in the pattern, so now we stick in OP_SKIPZERO in front of it
+         so that it is skipped on execution. As we don't have a list of which
+         groups are referenced, we cannot do this selectively.
+         If the maximum is 1 or unlimited, we just have to stick in the BRAZERO
+         and do no more at this point. However, we do need to adjust any
+         OP_RECURSE calls inside the group that refer to the group itself or any
+         internal or forward referenced group, because the offset is from the
+         start of the whole regex. Temporarily terminate the pattern while doing
+         this. */
-         if (repeat_max <= 1)
+         if (repeat_max <= 1)    /* Covers 0, 1, and unlimited */
            {
            *code = OP_END;
            adjust_recurse(previous, 1, utf8, cd, save_hwm);
            memmove(previous+1, previous, len);
            code++;
+           if (repeat_max == 0)
+             {
+             *previous++ = OP_SKIPZERO;
+             goto END_REPEAT;
+             }
            *previous++ = OP_BRAZERO + repeat_type;
            }
-Line 3846 
 we set the flag only if there is a liter
+Line 4258 
 we set the flag only if there is a liter
            {
            /* In the pre-compile phase, we don't actually do the replication. We
            just adjust the length as if we had. Do some paranoid checks for
-           potential integer overflow. */
+           potential integer overflow. The INT64_OR_DOUBLE type is a 64-bit
+           integer type when available, otherwise double. */
            if (lengthptr != NULL)
              {
              int delta = (repeat_min - 1)*length_prevgroup;
-             if ((double)(repeat_min - 1)*(double)length_prevgroup >
+             if ((INT64_OR_DOUBLE)(repeat_min - 1)*
-                                                             (double)INT_MAX ||
+                   (INT64_OR_DOUBLE)length_prevgroup >
+                     (INT64_OR_DOUBLE)INT_MAX ||
                  OFLOW_MAX - *lengthptr < delta)
                {
                *errorcodeptr = ERR20;
-Line 3898 
 we set the flag only if there is a liter
+Line 4312 
 we set the flag only if there is a liter
          just adjust the length as if we had. For each repetition we must add 1
          to the length for BRAZERO and for all but the last repetition we must
          add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
-         paranoid checks to avoid integer overflow. */
+         paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type is
+         a 64-bit integer type when available, otherwise double. */
          if (lengthptr != NULL && repeat_max > 0)
            {
            int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
 - 2*LINK_SIZE;   /* Last one doesn't nest */
-           if ((double)repeat_max *
+           if ((INT64_OR_DOUBLE)repeat_max *
-                 (double)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
+                 (INT64_OR_DOUBLE)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
-                   > (double)INT_MAX ||
+                   > (INT64_OR_DOUBLE)INT_MAX ||
                OFLOW_MAX - *lengthptr < delta)
              {
              *errorcodeptr = ERR20;
-Line 3983 
 we set the flag only if there is a liter
+Line 4398 
 we set the flag only if there is a liter
            uschar *scode = bracode;
            do
              {
-             if (could_be_empty_branch(scode, ketcode, utf8))
+             if (could_be_empty_branch(scode, ketcode, utf8, cd))
                {
                *bracode += OP_SBRA - OP_BRA;
                break;
-Line 3995 
 we set the flag only if there is a liter
+Line 4410 
 we set the flag only if there is a liter
          }
        }
+     /* If previous is OP_FAIL, it was generated by an empty class [] in
+     JavaScript mode. The other ways in which OP_FAIL can be generated, that is
+     by (*FAIL) or (?!) set previous to NULL, which gives a "nothing to repeat"
+     error above. We can just ignore the repeat in JS case. */
+     else if (*previous == OP_FAIL) goto END_REPEAT;
      /* Else there's some kind of shambles */
      else
-Line 4019 
 we set the flag only if there is a liter
+Line 4441 
 we set the flag only if there is a liter
      if (possessive_quantifier)
        {
        int len;
-       if (*tempcode == OP_EXACT || *tempcode == OP_TYPEEXACT ||
-           *tempcode == OP_NOTEXACT)
+       if (*tempcode == OP_TYPEEXACT)
+         tempcode += _pcre_OP_lengths[*tempcode] +
+           ((tempcode[3] == OP_PROP || tempcode[3] == OP_NOTPROP)? 2 : 0);
+       else if (*tempcode == OP_EXACT || *tempcode == OP_NOTEXACT)
+         {
          tempcode += _pcre_OP_lengths[*tempcode];
+ #ifdef SUPPORT_UTF8
+         if (utf8 && tempcode[-1] >= 0xc0)
+           tempcode += _pcre_utf8_table4[tempcode[-1] & 0x3f];
+ #endif
+         }
        len = code - tempcode;
        if (len > 0) switch (*tempcode)
          {
-Line 4040 
 we set the flag only if there is a liter
+Line 4473 
 we set the flag only if there is a liter
          case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;
          case OP_NOTUPTO:  *tempcode = OP_NOTPOSUPTO; 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, utf8, cd, save_hwm);
          memmove(tempcode + 1+LINK_SIZE, tempcode, len);
          code += 1 + LINK_SIZE;
          len += 1 + LINK_SIZE;
-Line 4067 
 we set the flag only if there is a liter
+Line 4505 
 we set the flag only if there is a liter
      lookbehind or option setting or condition or all the other extended
      parenthesis forms.  */
-     case '(':
+     case CHAR_LEFT_PARENTHESIS:
      newoptions = options;
      skipbytes = 0;
      bravalue = OP_CBRA;
-Line 4076 
 we set the flag only if there is a liter
+Line 4514 
 we set the flag only if there is a liter
      /* First deal with various "verbs" that can be introduced by '*'. */
-     if (*(++ptr) == '*' && (cd->ctypes[ptr[1]] & ctype_letter) != 0)
+     if (*(++ptr) == CHAR_ASTERISK && (cd->ctypes[ptr[1]] & ctype_letter) != 0)
        {
        int i, namelen;
        const char *vn = verbnames;
        const uschar *name = ++ptr;
        previous = NULL;
-       while ((cd->ctypes[*++ptr] & ctype_letter) != 0);
+       while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};
-       if (*ptr == ':')
+       if (*ptr == CHAR_COLON)
          {
          *errorcodeptr = ERR59;   /* Not supported */
          goto FAILED;
          }
-       if (*ptr != ')')
+       if (*ptr != CHAR_RIGHT_PARENTHESIS)
          {
          *errorcodeptr = ERR60;
          goto FAILED;
-Line 4099 
 we set the flag only if there is a liter
+Line 4537 
 we set the flag only if there is a liter
          if (namelen == verbs[i].len &&
              strncmp((char *)name, vn, namelen) == 0)
            {
-           *code = verbs[i].op;
+           /* Check for open captures before ACCEPT */
-           if (*code++ == OP_ACCEPT) cd->had_accept = TRUE;
+           if (verbs[i].op == OP_ACCEPT)
+             {
+             open_capitem *oc;
+             cd->had_accept = TRUE;
+             for (oc = cd->open_caps; oc != NULL; oc = oc->next)
+               {
+               *code++ = OP_CLOSE;
+               PUT2INC(code, 0, oc->number);
+               }
+             }
+           *code++ = verbs[i].op;
            break;
            }
          vn += verbs[i].len + 1;
-Line 4113 
 we set the flag only if there is a liter
+Line 4562 
 we set the flag only if there is a liter
      /* 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 == '?')
+     else if (*ptr == CHAR_QUESTION_MARK)
        {
        int i, set, unset, namelen;
        int *optset;
-Line 4122 
 we set the flag only if there is a liter
+Line 4571 
 we set the flag only if there is a liter
        switch (*(++ptr))
          {
-         case '#':                 /* Comment; skip to ket */
+         case CHAR_NUMBER_SIGN:                 /* Comment; skip to ket */
          ptr++;
-         while (*ptr != 0 && *ptr != ')') ptr++;
+         while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
          if (*ptr == 0)
            {
            *errorcodeptr = ERR18;
-Line 4134 
 we set the flag only if there is a liter
+Line 4583 
 we set the flag only if there is a liter
          /* ------------------------------------------------------------ */
-         case '|':                 /* Reset capture count for each branch */
+         case CHAR_VERTICAL_LINE:  /* Reset capture count for each branch */
          reset_bracount = TRUE;
          /* Fall through */
          /* ------------------------------------------------------------ */
-         case ':':                 /* Non-capturing bracket */
+         case CHAR_COLON:          /* Non-capturing bracket */
          bravalue = OP_BRA;
          ptr++;
          break;
          /* ------------------------------------------------------------ */
-         case '(':
+         case CHAR_LEFT_PARENTHESIS:
          bravalue = OP_COND;       /* Conditional group */
          /* A condition can be an assertion, a number (referring to a numbered
-Line 4166 
 we set the flag only if there is a liter
+Line 4615 
 we set the flag only if there is a liter
          the switch. This will take control down to where bracketed groups,
          including assertions, are processed. */
-         if (ptr[1] == '?' && (ptr[2] == '=' || ptr[2] == '!' || ptr[2] == '<'))
+         if (ptr[1] == CHAR_QUESTION_MARK && (ptr[2] == CHAR_EQUALS_SIGN ||
+             ptr[2] == CHAR_EXCLAMATION_MARK || ptr[2] == CHAR_LESS_THAN_SIGN))
            break;
          /* Most other conditions use OP_CREF (a couple change to OP_RREF
-Line 4178 
 we set the flag only if there is a liter
+Line 4628 
 we set the flag only if there is a liter
          /* Check for a test for recursion in a named group. */
-         if (ptr[1] == 'R' && ptr[2] == '&')
+         if (ptr[1] == CHAR_R && ptr[2] == CHAR_AMPERSAND)
            {
            terminator = -1;
            ptr += 2;
-Line 4188 
 we set the flag only if there is a liter
+Line 4638 
 we set the flag only if there is a liter
          /* Check for a test for a named group's having been set, using the Perl
          syntax (?(<name>) or (?('name') */
-         else if (ptr[1] == '<')
+         else if (ptr[1] == CHAR_LESS_THAN_SIGN)
            {
-           terminator = '>';
+           terminator = CHAR_GREATER_THAN_SIGN;
            ptr++;
            }
-         else if (ptr[1] == '\'')
+         else if (ptr[1] == CHAR_APOSTROPHE)
            {
-           terminator = '\'';
+           terminator = CHAR_APOSTROPHE;
            ptr++;
            }
          else
            {
            terminator = 0;
-           if (ptr[1] == '-' || ptr[1] == '+') refsign = *(++ptr);
+           if (ptr[1] == CHAR_MINUS || ptr[1] == CHAR_PLUS) refsign = *(++ptr);
            }
          /* We now expect to read a name; any thing else is an error */
-Line 4221 
 we set the flag only if there is a liter
+Line 4671 
 we set the flag only if there is a liter
            {
            if (recno >= 0)
              recno = ((digitab[*ptr] & ctype_digit) != 0)?
-               recno * 10 + *ptr - '0' : -1;
+               recno * 10 + *ptr - CHAR_0 : -1;
            ptr++;
            }
          namelen = ptr - name;
-         if ((terminator > 0 && *ptr++ != terminator) || *ptr++ != ')')
+         if ((terminator > 0 && *ptr++ != terminator) ||
+             *ptr++ != CHAR_RIGHT_PARENTHESIS)
            {
            ptr--;      /* Error offset */
            *errorcodeptr = ERR26;
-Line 4248 
 we set the flag only if there is a liter
+Line 4699 
 we set the flag only if there is a liter
              *errorcodeptr = ERR58;
              goto FAILED;
              }
-           recno = (refsign == '-')?
+           recno = (refsign == CHAR_MINUS)?
              cd->bracount - recno + 1 : recno +cd->bracount;
            if (recno <= 0 || recno > cd->final_bracount)
              {
-Line 4260 
 we set the flag only if there is a liter
+Line 4711 
 we set the flag only if there is a liter
            }
          /* Otherwise (did not start with "+" or "-"), start by looking for the
-         name. */
+         name. If we find a name, add one to the opcode to change OP_CREF or
+         OP_RREF into OP_NCREF or OP_NRREF. These behave exactly the same,
+         except they record that the reference was originally to a name. The
+         information is used to check duplicate names. */
          slot = cd->name_table;
          for (i = 0; i < cd->names_found; i++)
-Line 4275 
 we set the flag only if there is a liter
+Line 4729 
 we set the flag only if there is a liter
            {
            recno = GET2(slot, 0);
            PUT2(code, 2+LINK_SIZE, recno);
+           code[1+LINK_SIZE]++;
            }
          /* Search the pattern for a forward reference */
-         else if ((i = find_parens(ptr, cd->bracount, name, namelen,
+         else if ((i = find_parens(cd, name, namelen,
                          (options & PCRE_EXTENDED) != 0)) > 0)
            {
            PUT2(code, 2+LINK_SIZE, i);
+           code[1+LINK_SIZE]++;
            }
          /* If terminator == 0 it means that the name followed directly after
-Line 4300 
 we set the flag only if there is a liter
+Line 4756 
 we set the flag only if there is a liter
          /* Check for (?(R) for recursion. Allow digits after R to specify a
          specific group number. */
-         else if (*name == 'R')
+         else if (*name == CHAR_R)
            {
            recno = 0;
            for (i = 1; i < namelen; i++)
-Line 4310 
 we set the flag only if there is a liter
+Line 4766 
 we set the flag only if there is a liter
                *errorcodeptr = ERR15;
                goto FAILED;
                }
-             recno = recno * 10 + name[i] - '0';
+             recno = recno * 10 + name[i] - CHAR_0;
              }
            if (recno == 0) recno = RREF_ANY;
            code[1+LINK_SIZE] = OP_RREF;      /* Change test type */
-Line 4320 
 we set the flag only if there is a liter
+Line 4776 
 we set the flag only if there is a liter
          /* Similarly, check for the (?(DEFINE) "condition", which is always
          false. */
-         else if (namelen == 6 && strncmp((char *)name, "DEFINE", 6) == 0)
+         else if (namelen == 6 && strncmp((char *)name, STRING_DEFINE, 6) == 0)
            {
            code[1+LINK_SIZE] = OP_DEF;
            skipbytes = 1;
            }
          /* Check for the "name" actually being a subpattern number. We are
          in the second pass here, so final_bracount is set. */
          else if (recno > 0 && recno <= cd->final_bracount)
            {
-Line 4345 
 we set the flag only if there is a liter
+Line 4801 
 we set the flag only if there is a liter
          /* ------------------------------------------------------------ */
-         case '=':                 /* Positive lookahead */
+         case CHAR_EQUALS_SIGN:                 /* Positive lookahead */
          bravalue = OP_ASSERT;
          ptr++;
          break;
          /* ------------------------------------------------------------ */
-         case '!':                 /* Negative lookahead */
+         case CHAR_EXCLAMATION_MARK:            /* Negative lookahead */
          ptr++;
-         if (*ptr == ')')          /* Optimize (?!) */
+         if (*ptr == CHAR_RIGHT_PARENTHESIS)    /* Optimize (?!) */
            {
            *code++ = OP_FAIL;
            previous = NULL;
-Line 4365 
 we set the flag only if there is a liter
+Line 4821 
 we set the flag only if there is a liter
          /* ------------------------------------------------------------ */
-         case '<':                 /* Lookbehind or named define */
+         case CHAR_LESS_THAN_SIGN:              /* Lookbehind or named define */
          switch (ptr[1])
            {
-           case '=':               /* Positive lookbehind */
+           case CHAR_EQUALS_SIGN:               /* Positive lookbehind */
            bravalue = OP_ASSERTBACK;
            ptr += 2;
            break;
-           case '!':               /* Negative lookbehind */
+           case CHAR_EXCLAMATION_MARK:          /* Negative lookbehind */
            bravalue = OP_ASSERTBACK_NOT;
            ptr += 2;
            break;
-Line 4388 
 we set the flag only if there is a liter
+Line 4844 
 we set the flag only if there is a liter
          /* ------------------------------------------------------------ */
-         case '>':                 /* One-time brackets */
+         case CHAR_GREATER_THAN_SIGN:           /* One-time brackets */
          bravalue = OP_ONCE;
          ptr++;
          break;
          /* ------------------------------------------------------------ */
-         case 'C':                 /* Callout - may be followed by digits; */
+         case CHAR_C:                 /* Callout - may be followed by digits; */
          previous_callout = code;  /* Save for later completion */
          after_manual_callout = 1; /* Skip one item before completing */
          *code++ = OP_CALLOUT;
            {
            int n = 0;
            while ((digitab[*(++ptr)] & ctype_digit) != 0)
-             n = n * 10 + *ptr - '0';
+             n = n * 10 + *ptr - CHAR_0;
-           if (*ptr != ')')
+           if (*ptr != CHAR_RIGHT_PARENTHESIS)
              {
              *errorcodeptr = ERR39;
              goto FAILED;
-Line 4423 
 we set the flag only if there is a liter
+Line 4879 
 we set the flag only if there is a liter
          /* ------------------------------------------------------------ */
-         case 'P':                 /* Python-style named subpattern handling */
+         case CHAR_P:              /* Python-style named subpattern handling */
-         if (*(++ptr) == '=' || *ptr == '>')  /* Reference or recursion */
+         if (*(++ptr) == CHAR_EQUALS_SIGN ||
+             *ptr == CHAR_GREATER_THAN_SIGN)  /* Reference or recursion */
            {
-           is_recurse = *ptr == '>';
+           is_recurse = *ptr == CHAR_GREATER_THAN_SIGN;
-           terminator = ')';
+           terminator = CHAR_RIGHT_PARENTHESIS;
            goto NAMED_REF_OR_RECURSE;
            }
-         else if (*ptr != '<')    /* Test for Python-style definition */
+         else if (*ptr != CHAR_LESS_THAN_SIGN)  /* Test for Python-style defn */
            {
            *errorcodeptr = ERR41;
            goto FAILED;
-Line 4440 
 we set the flag only if there is a liter
+Line 4897 
 we set the flag only if there is a liter
          /* ------------------------------------------------------------ */
          DEFINE_NAME:    /* Come here from (?< handling */
-         case '\'':
+         case CHAR_APOSTROPHE:
            {
-           terminator = (*ptr == '<')? '>' : '\'';
+           terminator = (*ptr == CHAR_LESS_THAN_SIGN)?
+             CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;
            name = ++ptr;
            while ((cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
-Line 4473 
 we set the flag only if there is a liter
+Line 4931 
 we set the flag only if there is a liter
                }
              }
-           /* In the real compile, create the entry in the table */
+           /* In the real compile, create the entry in the table, maintaining
+           alphabetical order. Duplicate names for different numbers are
+           permitted only if PCRE_DUPNAMES is set. Duplicate names for the same
+           number are always OK. (An existing number can be re-used if (?|
+           appears in the pattern.) In either event, a duplicate name results in
+           a duplicate entry in the table, even if the number is the same. This
+           is because the number of names, and hence the table size, is computed
+           in the pre-compile, and it affects various numbers and pointers which
+           would all have to be modified, and the compiled code moved down, if
+           duplicates with the same number were omitted from the table. This
+           doesn't seem worth the hassle. However, *different* names for the
+           same number are not permitted. */
            else
              {
+             BOOL dupname = FALSE;
              slot = cd->name_table;
              for (i = 0; i < cd->names_found; i++)
                {
                int crc = memcmp(name, slot+2, namelen);
-Line 4485 
 we set the flag only if there is a liter
+Line 4956 
 we set the flag only if there is a liter
                  {
                  if (slot[2+namelen] == 0)
                    {
-                   if ((options & PCRE_DUPNAMES) == 0)
+                   if (GET2(slot, 0) != cd->bracount + 1 &&
+                       (options & PCRE_DUPNAMES) == 0)
                      {
                      *errorcodeptr = ERR43;
                      goto FAILED;
                      }
+                   else dupname = TRUE;
                    }
-                 else crc = -1;      /* Current name is substring */
+                 else crc = -1;      /* Current name is a substring */
                  }
+               /* Make space in the table and break the loop for an earlier
+               name. For a duplicate or later name, carry on. We do this for
+               duplicates so that in the simple case (when ?(| is not used) they
+               are in order of their numbers. */
                if (crc < 0)
                  {
                  memmove(slot + cd->name_entry_size, slot,
                    (cd->names_found - i) * cd->name_entry_size);
                  break;
                  }
+               /* Continue the loop for a later or duplicate name */
                slot += cd->name_entry_size;
                }
+             /* For non-duplicate names, check for a duplicate number before
+             adding the new name. */
+             if (!dupname)
+               {
+               uschar *cslot = cd->name_table;
+               for (i = 0; i < cd->names_found; i++)
+                 {
+                 if (cslot != slot)
+                   {
+                   if (GET2(cslot, 0) == cd->bracount + 1)
+                     {
+                     *errorcodeptr = ERR65;
+                     goto FAILED;
+                     }
+                   }
+                 else i--;
+                 cslot += cd->name_entry_size;
+                 }
+               }
              PUT2(slot, 0, cd->bracount + 1);
              memcpy(slot + 2, name, namelen);
              slot[2+namelen] = 0;
              }
            }
-         /* In both cases, count the number of names we've encountered. */
+         /* In both pre-compile and compile, count the number of names we've
+         encountered. */
-         ptr++;                    /* Move past > or ' */
          cd->names_found++;
+         ptr++;                    /* Move past > or ' */
          goto NUMBERED_GROUP;
          /* ------------------------------------------------------------ */
-         case '&':                 /* Perl recursion/subroutine syntax */
+         case CHAR_AMPERSAND:            /* Perl recursion/subroutine syntax */
-         terminator = ')';
+         terminator = CHAR_RIGHT_PARENTHESIS;
          is_recurse = TRUE;
          /* Fall through */
-Line 4525 
 we set the flag only if there is a liter
+Line 5029 
 we set the flag only if there is a liter
          references (?P=name) and recursion (?P>name), as well as falling
          through from the Perl recursion syntax (?&name). We also come here from
          the Perl \k<name> or \k'name' back reference syntax and the \k{name}
-         .NET syntax. */
+         .NET syntax, and the Oniguruma \g<...> and \g'...' subroutine syntax. */
          NAMED_REF_OR_RECURSE:
          name = ++ptr;
-Line 4541 
 we set the flag only if there is a liter
+Line 5045 
 we set the flag only if there is a liter
              {
              *errorcodeptr = ERR62;
              goto FAILED;
              }
            if (*ptr != terminator)
              {
              *errorcodeptr = ERR42;
-Line 4555 
 we set the flag only if there is a liter
+Line 5059 
 we set the flag only if there is a liter
            recno = 0;
            }
          /* In the real compile, seek the name in the table. We check the name
          first, and then check that we have reached the end of the name in the
          table. That way, if the name that is longer than any in the table,
          the comparison will fail without reading beyond the table entry. */
-Line 4566 
 we set the flag only if there is a liter
+Line 5070 
 we set the flag only if there is a liter
            for (i = 0; i < cd->names_found; i++)
              {
              if (strncmp((char *)name, (char *)slot+2, namelen) == 0 &&
                  slot[2+namelen] == 0)
                break;
              slot += cd->name_entry_size;
              }
-Line 4576 
 we set the flag only if there is a liter
+Line 5080 
 we set the flag only if there is a liter
              recno = GET2(slot, 0);
              }
            else if ((recno =                /* Forward back reference */
-                     find_parens(ptr, cd->bracount, name, namelen,
+                     find_parens(cd, name, namelen,
                        (options & PCRE_EXTENDED) != 0)) <= 0)
              {
              *errorcodeptr = ERR15;
-Line 4592 
 we set the flag only if there is a liter
+Line 5096 
 we set the flag only if there is a liter
          /* ------------------------------------------------------------ */
-         case 'R':                 /* Recursion */
+         case CHAR_R:              /* Recursion */
          ptr++;                    /* Same as (?0)      */
          /* Fall through */
          /* ------------------------------------------------------------ */
-         case '-': case '+':
+         case CHAR_MINUS: case CHAR_PLUS:  /* Recursion or subroutine */
-         case '0': case '1': case '2': case '3': case '4':   /* Recursion or */
+         case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4:
-         case '5': case '6': case '7': case '8': case '9':   /* subroutine */
+         case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
            {
            const uschar *called;
+           terminator = CHAR_RIGHT_PARENTHESIS;
+           /* Come here from the \g<...> and \g'...' code (Oniguruma
+           compatibility). However, the syntax has been checked to ensure that
+           the ... are a (signed) number, so that neither ERR63 nor ERR29 will
+           be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY
+           ever be taken. */
-           if ((refsign = *ptr) == '+')
+           HANDLE_NUMERICAL_RECURSION:
+           if ((refsign = *ptr) == CHAR_PLUS)
              {
              ptr++;
              if ((digitab[*ptr] & ctype_digit) == 0)
                {
                *errorcodeptr = ERR63;
                goto FAILED;
                }
              }
-           else if (refsign == '-')
+           else if (refsign == CHAR_MINUS)
              {
              if ((digitab[ptr[1]] & ctype_digit) == 0)
                goto OTHER_CHAR_AFTER_QUERY;
-Line 4622 
 we set the flag only if there is a liter
+Line 5135 
 we set the flag only if there is a liter
            recno = 0;
            while((digitab[*ptr] & ctype_digit) != 0)
-             recno = recno * 10 + *ptr++ - '0';
+             recno = recno * 10 + *ptr++ - CHAR_0;
-           if (*ptr != ')')
+           if (*ptr != terminator)
              {
              *errorcodeptr = ERR29;
              goto FAILED;
              }
-           if (refsign == '-')
+           if (refsign == CHAR_MINUS)
              {
              if (recno == 0)
                {
-Line 4644 
 we set the flag only if there is a liter
+Line 5157 
 we set the flag only if there is a liter
                goto FAILED;
                }
              }
-           else if (refsign == '+')
+           else if (refsign == CHAR_PLUS)
              {
              if (recno == 0)
                {
-Line 4671 
 we set the flag only if there is a liter
+Line 5184 
 we set the flag only if there is a liter
            if (lengthptr == NULL)
              {
              *code = OP_END;
-             if (recno != 0) called = find_bracket(cd->start_code, utf8, recno);
+             if (recno != 0)
+               called = _pcre_find_bracket(cd->start_code, utf8, recno);
              /* Forward reference */
              if (called == NULL)
                {
-               if (find_parens(ptr, cd->bracount, NULL, recno,
+               if (find_parens(cd, NULL, recno,
-                    (options & PCRE_EXTENDED) != 0) < 0)
+                     (options & PCRE_EXTENDED) != 0) < 0)
                  {
                  *errorcodeptr = ERR15;
                  goto FAILED;
                  }
+               /* Fudge the value of "called" so that when it is inserted as an
+               offset below, what it actually inserted is the reference number
+               of the group. */
                called = cd->start_code + recno;
                PUTINC(cd->hwm, 0, code + 2 + LINK_SIZE - cd->start_code);
                }
-Line 4692 
 we set the flag only if there is a liter
+Line 5211 
 we set the flag only if there is a liter
              recursion that could loop for ever, and diagnose that case. */
              else if (GET(called, 1) == 0 &&
-                      could_be_empty(called, code, bcptr, utf8))
+                      could_be_empty(called, code, bcptr, utf8, cd))
                {
                *errorcodeptr = ERR40;
                goto FAILED;
-Line 4730 
 we set the flag only if there is a liter
+Line 5249 
 we set the flag only if there is a liter
          set = unset = 0;
          optset = &set;
-         while (*ptr != ')' && *ptr != ':')
+         while (*ptr != CHAR_RIGHT_PARENTHESIS && *ptr != CHAR_COLON)
            {
            switch (*ptr++)
              {
-             case '-': optset = &unset; break;
+             case CHAR_MINUS: optset = &unset; break;
-             case 'J':    /* Record that it changed in the external options */
+             case CHAR_J:    /* Record that it changed in the external options */
              *optset |= PCRE_DUPNAMES;
              cd->external_flags |= PCRE_JCHANGED;
              break;
-             case 'i': *optset |= PCRE_CASELESS; break;
+             case CHAR_i: *optset |= PCRE_CASELESS; break;
-             case 'm': *optset |= PCRE_MULTILINE; break;
+             case CHAR_m: *optset |= PCRE_MULTILINE; break;
-             case 's': *optset |= PCRE_DOTALL; break;
+             case CHAR_s: *optset |= PCRE_DOTALL; break;
-             case 'x': *optset |= PCRE_EXTENDED; break;
+             case CHAR_x: *optset |= PCRE_EXTENDED; break;
-             case 'U': *optset |= PCRE_UNGREEDY; break;
+             case CHAR_U: *optset |= PCRE_UNGREEDY; break;
-             case 'X': *optset |= PCRE_EXTRA; break;
+             case CHAR_X: *optset |= PCRE_EXTRA; break;
              default:  *errorcodeptr = ERR12;
                        ptr--;    /* Correct the offset */
-Line 4777 
 we set the flag only if there is a liter
+Line 5296 
 we set the flag only if there is a liter
          both phases.
          If we are not at the pattern start, compile code to change the ims
-         options if this setting actually changes any of them. We also pass the
+         options if this setting actually changes any of them, and reset the
-         new setting back so that it can be put at the start of any following
+         greedy defaults and the case value for firstbyte and reqbyte. */
-         branches, and when this group ends (if we are in a group), a resetting
-         item can be compiled. */
-         if (*ptr == ')')
+         if (*ptr == CHAR_RIGHT_PARENTHESIS)
            {
            if (code == cd->start_code + 1 + LINK_SIZE &&
                 (lengthptr == NULL || *lengthptr == 2 + 2*LINK_SIZE))
              {
              cd->external_options = newoptions;
-             options = newoptions;
              }
-          else
+           else
              {
              if ((options & PCRE_IMS) != (newoptions & PCRE_IMS))
                {
                *code++ = OP_OPT;
                *code++ = newoptions & PCRE_IMS;
                }
-             /* Change options at this level, and pass them back for use
-             in subsequent branches. Reset the greedy defaults and the case
-             value for firstbyte and reqbyte. */
-             *optionsptr = options = newoptions;
              greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
              greedy_non_default = greedy_default ^ 1;
-             req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
+             req_caseopt = ((newoptions & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
              }
+           /* Change options at this level, and pass them back for use
+           in subsequent branches. When not at the start of the pattern, this
+           information is also necessary so that a resetting item can be
+           compiled at the end of a group (if we are in a group). */
+           *optionsptr = options = newoptions;
            previous = NULL;       /* This item can't be repeated */
            continue;              /* It is complete */
            }
-Line 4923 
 we set the flag only if there is a liter
+Line 5439 
 we set the flag only if there is a liter
      /* Error if hit end of pattern */
-     if (*ptr != ')')
+     if (*ptr != CHAR_RIGHT_PARENTHESIS)
        {
        *errorcodeptr = ERR14;
        goto FAILED;
-Line 5021 
 we set the flag only if there is a liter
+Line 5537 
 we set the flag only if there is a liter
      We can test for values between ESC_b and ESC_Z for the latter; this may
      have to change if any new ones are ever created. */
-     case '\\':
+     case CHAR_BACKSLASH:
      tempptr = ptr;
      c = check_escape(&ptr, errorcodeptr, cd->bracount, options, FALSE);
      if (*errorcodeptr != 0) goto FAILED;
-Line 5030 
 we set the flag only if there is a liter
+Line 5546 
 we set the flag only if there is a liter
        {
        if (-c == ESC_Q)            /* Handle start of quoted string */
          {
-         if (ptr[1] == '\\' && ptr[2] == 'E') ptr += 2; /* avoid empty string */
+         if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
-           else inescq = TRUE;
+           ptr += 2;               /* avoid empty string */
+             else inescq = TRUE;
          continue;
          }
-Line 5048 
 we set the flag only if there is a liter
+Line 5565 
 we set the flag only if there is a liter
        zerofirstbyte = firstbyte;
        zeroreqbyte = reqbyte;
+       /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n'
+       is a subroutine call by number (Oniguruma syntax). In fact, the value
+       -ESC_g is returned only for these cases. So we don't need to check for <
+       or ' if the value is -ESC_g. For the Perl syntax \g{n} the value is
+       -ESC_REF+n, and for the Perl syntax \g{name} the result is -ESC_k (as
+       that is a synonym for a named back reference). */
+       if (-c == ESC_g)
+         {
+         const uschar *p;
+         save_hwm = cd->hwm;   /* Normally this is set when '(' is read */
+         terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
+           CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;
+         /* These two statements stop the compiler for warning about possibly
+         unset variables caused by the jump to HANDLE_NUMERICAL_RECURSION. In
+         fact, because we actually check for a number below, the paths that
+         would actually be in error are never taken. */
+         skipbytes = 0;
+         reset_bracount = FALSE;
+         /* Test for a name */
+         if (ptr[1] != CHAR_PLUS && ptr[1] != CHAR_MINUS)
+           {
+           BOOL isnumber = TRUE;
+           for (p = ptr + 1; *p != 0 && *p != terminator; p++)
+             {
+             if ((cd->ctypes[*p] & ctype_digit) == 0) isnumber = FALSE;
+             if ((cd->ctypes[*p] & ctype_word) == 0) break;
+             }
+           if (*p != terminator)
+             {
+             *errorcodeptr = ERR57;
+             break;
+             }
+           if (isnumber)
+             {
+             ptr++;
+             goto HANDLE_NUMERICAL_RECURSION;
+             }
+           is_recurse = TRUE;
+           goto NAMED_REF_OR_RECURSE;
+           }
+         /* Test a signed number in angle brackets or quotes. */
+         p = ptr + 2;
+         while ((digitab[*p] & ctype_digit) != 0) p++;
+         if (*p != terminator)
+           {
+           *errorcodeptr = ERR57;
+           break;
+           }
+         ptr++;
+         goto HANDLE_NUMERICAL_RECURSION;
+         }
        /* \k<name> or \k'name' is a back reference by name (Perl syntax).
        We also support \k{name} (.NET syntax) */
-       if (-c == ESC_k && (ptr[1] == '<' || ptr[1] == '\'' || ptr[1] == '{'))
+       if (-c == ESC_k && (ptr[1] == CHAR_LESS_THAN_SIGN ||
+           ptr[1] == CHAR_APOSTROPHE || ptr[1] == CHAR_LEFT_CURLY_BRACKET))
          {
          is_recurse = FALSE;
-         terminator = (*(++ptr) == '<')? '>' : (*ptr == '\'')? '\'' : '}';
+         terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
+           CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?
+           CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;
          goto NAMED_REF_OR_RECURSE;
          }
-Line 5064 
 we set the flag only if there is a liter
+Line 5643 
 we set the flag only if there is a liter
        if (-c >= ESC_REF)
          {
+         open_capitem *oc;
          recno = -c - ESC_REF;
          HANDLE_REFERENCE:    /* Come here from named backref handling */
-Line 5073 
 we set the flag only if there is a liter
+Line 5653 
 we set the flag only if there is a liter
          PUT2INC(code, 0, recno);
          cd->backref_map |= (recno < 32)? (1 << recno) : 1;
          if (recno > cd->top_backref) cd->top_backref = recno;
+         /* Check to see if this back reference is recursive, that it, it
+         is inside the group that it references. A flag is set so that the
+         group can be made atomic. */
+         for (oc = cd->open_caps; oc != NULL; oc = oc->next)
+           {
+           if (oc->number == recno)
+             {
+             oc->flag = TRUE;
+             break;
+             }
+           }
          }
        /* So are Unicode property matches, if supported. */
-Line 5157 
 we set the flag only if there is a liter
+Line 5750 
 we set the flag only if there is a liter
      /* Remember if \r or \n were seen */
-     if (mcbuffer[0] == '\r' || mcbuffer[0] == '\n')
+     if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL)
        cd->external_flags |= PCRE_HASCRORLF;
      /* Set the first and required bytes appropriately. If no previous first
-Line 5255 
 uschar *code = *codeptr;
+Line 5848 
 uschar *code = *codeptr;
  uschar *last_branch = code;
  uschar *start_bracket = code;
  uschar *reverse_count = NULL;
+ open_capitem capitem;
+ int capnumber = 0;
  int firstbyte, reqbyte;
  int branchfirstbyte, branchreqbyte;
  int length;
  int orig_bracount;
  int max_bracount;
+ int old_external_options = cd->external_options;
  branch_chain bc;
  bc.outer = bcptr;
- bc.current = code;
+ bc.current_branch = code;
  firstbyte = reqbyte = REQ_UNSET;
-Line 5281 
 the code that abstracts option settings
+Line 5877 
 the code that abstracts option settings
  them global. It tests the value of length for (2 + 2*LINK_SIZE) in the
  pre-compile phase to find out whether anything has yet been compiled or not. */
+ /* If this is a capturing subpattern, add to the chain of open capturing items
+ so that we can detect them if (*ACCEPT) is encountered. This is also used to
+ detect groups that contain recursive back references to themselves. */
+ if (*code == OP_CBRA)
+   {
+   capnumber = GET2(code, 1 + LINK_SIZE);
+   capitem.number = capnumber;
+   capitem.next = cd->open_caps;
+   capitem.flag = FALSE;
+   cd->open_caps = &capitem;
+   }
  /* Offset is set zero to mark that this bracket is still open */
  PUT(code, 1, 0);
-Line 5325 
 for (;;)
+Line 5934 
 for (;;)
      return FALSE;
      }
+   /* If the external options have changed during this branch, it means that we
+   are at the top level, and a leading option setting has been encountered. We
+   need to re-set the original option values to take account of this so that,
+   during the pre-compile phase, we know to allow for a re-set at the start of
+   subsequent branches. */
+   if (old_external_options != cd->external_options)
+     oldims = cd->external_options & PCRE_IMS;
    /* Keep the highest bracket count in case (?| was used and some branch
    has fewer than the rest. */
-Line 5375 
 for (;;)
+Line 5993 
 for (;;)
      /* If lookbehind, check that this branch matches a fixed-length string, and
      put the length into the OP_REVERSE item. Temporarily mark the end of the
-     branch with OP_END. */
+     branch with OP_END. If the branch contains OP_RECURSE, the result is -3
+     because there may be forward references that we can't check here. Set a
+     flag to cause another lookbehind check at the end. Why not do it all at the
+     end? Because common, erroneous checks are picked up here and the offset of
+     the problem can be shown. */
      if (lookbehind)
        {
        int fixed_length;
        *code = OP_END;
-       fixed_length = find_fixedlength(last_branch, options);
+       fixed_length = find_fixedlength(last_branch, options, FALSE, cd);
        DPRINTF(("fixed length = %d\n", fixed_length));
-       if (fixed_length < 0)
+       if (fixed_length == -3)
+         {
+         cd->check_lookbehind = TRUE;
+         }
+       else if (fixed_length < 0)
          {
          *errorcodeptr = (fixed_length == -2)? ERR36 : ERR25;
          *ptrptr = ptr;
          return FALSE;
          }
-       PUT(reverse_count, 0, fixed_length);
+       else { PUT(reverse_count, 0, fixed_length); }
        }
      }
-Line 5402 
 for (;;)
+Line 6028 
 for (;;)
    compile a resetting op-code following, except at the very end of the pattern.
    Return leaving the pointer at the terminating char. */
-   if (*ptr != '|')
+   if (*ptr != CHAR_VERTICAL_LINE)
      {
      if (lengthptr == NULL)
        {
-Line 5423 
 for (;;)
+Line 6049 
 for (;;)
      PUT(code, 1, code - start_bracket);
      code += 1 + LINK_SIZE;
-     /* Resetting option if needed */
+     /* If it was a capturing subpattern, check to see if it contained any
+     recursive back references. If so, we must wrap it in atomic brackets.
+     In any event, remove the block from the chain. */
-     if ((options & PCRE_IMS) != oldims && *ptr == ')')
+     if (capnumber > 0)
+       {
+       if (cd->open_caps->flag)
+         {
+         memmove(start_bracket + 1 + LINK_SIZE, start_bracket,
+           code - start_bracket);
+         *start_bracket = OP_ONCE;
+         code += 1 + LINK_SIZE;
+         PUT(start_bracket, 1, code - start_bracket);
+         *code = OP_KET;
+         PUT(code, 1, code - start_bracket);
+         code += 1 + LINK_SIZE;
+         length += 2 + 2*LINK_SIZE;
+         }
+       cd->open_caps = cd->open_caps->next;
+       }
+     /* Reset options if needed. */
+     if ((options & PCRE_IMS) != oldims && *ptr == CHAR_RIGHT_PARENTHESIS)
        {
        *code++ = OP_OPT;
        *code++ = oldims;
-Line 5472 
 for (;;)
+Line 6119 
 for (;;)
      {
      *code = OP_ALT;
      PUT(code, 1, code - last_branch);
-     bc.current = last_branch = code;
+     bc.current_branch = last_branch = code;
      code += 1 + LINK_SIZE;
      }
-Line 5554 
 do {
+Line 6201 
 do {
       if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;
       }
-    /* .* is not anchored unless DOTALL is set and it isn't in brackets that
+    /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and
-    are or may be referenced. */
+    it isn't in brackets that are or may be referenced. */
     else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
-              op == OP_TYPEPOSSTAR) &&
+              op == OP_TYPEPOSSTAR))
-             (*options & PCRE_DOTALL) != 0)
       {
-      if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
+      if (scode[1] != OP_ALLANY || (bracket_map & backref_map) != 0)
+        return FALSE;
       }
     /* Check for explicit anchoring */
-Line 5607 
 do {
+Line 6254 
 do {
       NULL, 0, FALSE);
     register int op = *scode;
+    /* If we are at the start of a conditional assertion group, *both* the
+    conditional assertion *and* what follows the condition must satisfy the test
+    for start of line. Other kinds of condition fail. Note that there may be an
+    auto-callout at the start of a condition. */
+    if (op == OP_COND)
+      {
+      scode += 1 + LINK_SIZE;
+      if (*scode == OP_CALLOUT) scode += _pcre_OP_lengths[OP_CALLOUT];
+      switch (*scode)
+        {
+        case OP_CREF:
+        case OP_NCREF:
+        case OP_RREF:
+        case OP_NRREF:
+        case OP_DEF:
+        return FALSE;
+        default:     /* Assertion */
+        if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
+        do scode += GET(scode, 1); while (*scode == OP_ALT);
+        scode += 1 + LINK_SIZE;
+        break;
+        }
+      scode = first_significant_code(scode, NULL, 0, FALSE);
+      op = *scode;
+      }
     /* Non-capturing brackets */
     if (op == OP_BRA)
-Line 5625 
 do {
+Line 6300 
 do {
     /* Other brackets */
-    else if (op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
+    else if (op == OP_ASSERT || op == OP_ONCE)
-      { if (!is_startline(scode, bracket_map, backref_map)) return FALSE; }
+      {
+      if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
+      }
     /* .* means "start at start or after \n" if it isn't in brackets that
     may be referenced. */
-Line 5743 
 Returns:        pointer to compiled data
+Line 6420 
 Returns:        pointer to compiled data
                  with errorptr and erroroffset set
  */
- PCRE_EXP_DEFN pcre *
+ PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
  pcre_compile(const char *pattern, int options, const char **errorptr,
    int *erroroffset, const unsigned char *tables)
  {
-Line 5751 
 return pcre_compile2(pattern, options, N
+Line 6428 
 return pcre_compile2(pattern, options, N
  }
- PCRE_EXP_DEFN pcre *
+ PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
  pcre_compile2(const char *pattern, int options, int *errorcodeptr,
    const char **errorptr, int *erroroffset, const unsigned char *tables)
  {
-Line 5760 
 int length = 1;  /* For final END opcode
+Line 6437 
 int length = 1;  /* For final END opcode
  int firstbyte, reqbyte, newline;
  int errorcode = 0;
  int skipatstart = 0;
- #ifdef SUPPORT_UTF8
+ BOOL utf8 = (options & PCRE_UTF8) != 0;
- BOOL utf8;
- #endif
  size_t size;
  uschar *code;
  const uschar *codestart;
-Line 5778 
 to fill in forward references to subpatt
+Line 6453 
 to fill in forward references to subpatt
  uschar cworkspace[COMPILE_WORK_SIZE];
  /* Set this early so that early errors get offset 0. */
  ptr = (const uschar *)pattern;
-Line 5806 
 if (erroroffset == NULL)
+Line 6480 
 if (erroroffset == NULL)
  *erroroffset = 0;
- /* Can't support UTF8 unless PCRE has been compiled to include the code. */
- #ifdef SUPPORT_UTF8
- utf8 = (options & PCRE_UTF8) != 0;
- if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
-      (*erroroffset = _pcre_valid_utf8((uschar *)pattern, -1)) >= 0)
-   {
-   errorcode = ERR44;
-   goto PCRE_EARLY_ERROR_RETURN2;
-   }
- #else
- if ((options & PCRE_UTF8) != 0)
-   {
-   errorcode = ERR32;
-   goto PCRE_EARLY_ERROR_RETURN;
-   }
- #endif
- if ((options & ~PUBLIC_OPTIONS) != 0)
-   {
-   errorcode = ERR17;
-   goto PCRE_EARLY_ERROR_RETURN;
-   }
  /* Set up pointers to the individual character tables */
  if (tables == NULL) tables = _pcre_default_tables;
-Line 5838 
 cd->fcc = tables + fcc_offset;
+Line 6488 
 cd->fcc = tables + fcc_offset;
  cd->cbits = tables + cbits_offset;
  cd->ctypes = tables + ctypes_offset;
+ /* Check that all undefined public option bits are zero */
+ if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0)
+   {
+   errorcode = ERR17;
+   goto PCRE_EARLY_ERROR_RETURN;
+   }
  /* Check for global one-time settings at the start of the pattern, and remember
  the offset for later. */
- while (ptr[skipatstart] == '(' && ptr[skipatstart+1] == '*')
+ while (ptr[skipatstart] == CHAR_LEFT_PARENTHESIS &&
+        ptr[skipatstart+1] == CHAR_ASTERISK)
    {
    int newnl = 0;
    int newbsr = 0;
-   if (strncmp((char *)(ptr+skipatstart+2), "CR)", 3) == 0)
+   if (strncmp((char *)(ptr+skipatstart+2), STRING_UTF8_RIGHTPAR, 5) == 0)
+     { skipatstart += 7; options |= PCRE_UTF8; continue; }
+   if (strncmp((char *)(ptr+skipatstart+2), STRING_CR_RIGHTPAR, 3) == 0)
      { skipatstart += 5; newnl = PCRE_NEWLINE_CR; }
-   else if (strncmp((char *)(ptr+skipatstart+2), "LF)", 3)  == 0)
+   else if (strncmp((char *)(ptr+skipatstart+2), STRING_LF_RIGHTPAR, 3)  == 0)
      { skipatstart += 5; newnl = PCRE_NEWLINE_LF; }
-   else if (strncmp((char *)(ptr+skipatstart+2), "CRLF)", 5)  == 0)
+   else if (strncmp((char *)(ptr+skipatstart+2), STRING_CRLF_RIGHTPAR, 5)  == 0)
      { skipatstart += 7; newnl = PCRE_NEWLINE_CR + PCRE_NEWLINE_LF; }
-   else if (strncmp((char *)(ptr+skipatstart+2), "ANY)", 4) == 0)
+   else if (strncmp((char *)(ptr+skipatstart+2), STRING_ANY_RIGHTPAR, 4) == 0)
      { skipatstart += 6; newnl = PCRE_NEWLINE_ANY; }
-   else if (strncmp((char *)(ptr+skipatstart+2), "ANYCRLF)", 8)  == 0)
+   else if (strncmp((char *)(ptr+skipatstart+2), STRING_ANYCRLF_RIGHTPAR, 8) == 0)
      { skipatstart += 10; newnl = PCRE_NEWLINE_ANYCRLF; }
-   else if (strncmp((char *)(ptr+skipatstart+2), "BSR_ANYCRLF)", 12) == 0)
+   else if (strncmp((char *)(ptr+skipatstart+2), STRING_BSR_ANYCRLF_RIGHTPAR, 12) == 0)
      { skipatstart += 14; newbsr = PCRE_BSR_ANYCRLF; }
-   else if (strncmp((char *)(ptr+skipatstart+2), "BSR_UNICODE)", 12) == 0)
+   else if (strncmp((char *)(ptr+skipatstart+2), STRING_BSR_UNICODE_RIGHTPAR, 12) == 0)
      { skipatstart += 14; newbsr = PCRE_BSR_UNICODE; }
    if (newnl != 0)
-Line 5869 
 while (ptr[skipatstart] == '(' && ptr[sk
+Line 6531 
 while (ptr[skipatstart] == '(' && ptr[sk
    else break;
    }
+ /* Can't support UTF8 unless PCRE has been compiled to include the code. */
+ #ifdef SUPPORT_UTF8
+ if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
+      (*erroroffset = _pcre_valid_utf8((USPTR)pattern, -1)) >= 0)
+   {
+   errorcode = ERR44;
+   goto PCRE_EARLY_ERROR_RETURN2;
+   }
+ #else
+ if (utf8)
+   {
+   errorcode = ERR32;
+   goto PCRE_EARLY_ERROR_RETURN;
+   }
+ #endif
  /* Check validity of \R options. */
  switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
-Line 5887 
 current code allows for fixed one- or tw
+Line 6566 
 current code allows for fixed one- or tw
  switch (options & PCRE_NEWLINE_BITS)
    {
    case 0: newline = NEWLINE; break;   /* Build-time default */
-   case PCRE_NEWLINE_CR: newline = '\r'; break;
+   case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
-   case PCRE_NEWLINE_LF: newline = '\n'; break;
+   case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
    case PCRE_NEWLINE_CR+
-        PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;
+        PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
    case PCRE_NEWLINE_ANY: newline = -1; break;
    case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
    default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;
-Line 5951 
 cd->end_pattern = (const uschar *)(patte
+Line 6630 
 cd->end_pattern = (const uschar *)(patte
  cd->req_varyopt = 0;
  cd->external_options = options;
  cd->external_flags = 0;
+ cd->open_caps = NULL;
  /* Now do the pre-compile. On error, errorcode will be set non-zero, so we
  don't need to look at the result of the function here. The initial options have
-Line 6025 
 cd->start_code = codestart;
+Line 6705 
 cd->start_code = codestart;
  cd->hwm = cworkspace;
  cd->req_varyopt = 0;
  cd->had_accept = FALSE;
+ cd->check_lookbehind = FALSE;
+ cd->open_caps = NULL;
  /* Set up a starting, non-extracting bracket, then compile the expression. On
  error, errorcode will be set non-zero, so we don't need to look at the result
-Line 6050 
 if debugging, leave the test till after
+Line 6732 
 if debugging, leave the test till after
  *code++ = OP_END;
- #ifndef DEBUG
+ #ifndef PCRE_DEBUG
  if (code - codestart > length) errorcode = ERR23;
  #endif
-Line 6063 
 while (errorcode == 0 && cd->hwm > cwork
+Line 6745 
 while (errorcode == 0 && cd->hwm > cwork
    cd->hwm -= LINK_SIZE;
    offset = GET(cd->hwm, 0);
    recno = GET(codestart, offset);
-   groupptr = find_bracket(codestart, (re->options & PCRE_UTF8) != 0, recno);
+   groupptr = _pcre_find_bracket(codestart, utf8, recno);
    if (groupptr == NULL) errorcode = ERR53;
      else PUT(((uschar *)codestart), offset, groupptr - codestart);
    }
-Line 6073 
 subpattern. */
+Line 6755 
 subpattern. */
  if (errorcode == 0 && re->top_backref > re->top_bracket) errorcode = ERR15;
+ /* If there were any lookbehind assertions that contained OP_RECURSE
+ (recursions or subroutine calls), a flag is set for them to be checked here,
+ because they may contain forward references. Actual recursions can't be fixed
+ length, but subroutine calls can. It is done like this so that those without
+ OP_RECURSE that are not fixed length get a diagnosic with a useful offset. The
+ exceptional ones forgo this. We scan the pattern to check that they are fixed
+ length, and set their lengths. */
+ if (cd->check_lookbehind)
+   {
+   uschar *cc = (uschar *)codestart;
+   /* Loop, searching for OP_REVERSE items, and process those that do not have
+   their length set. (Actually, it will also re-process any that have a length
+   of zero, but that is a pathological case, and it does no harm.) When we find
+   one, we temporarily terminate the branch it is in while we scan it. */
+   for (cc = (uschar *)_pcre_find_bracket(codestart, utf8, -1);
+        cc != NULL;
+        cc = (uschar *)_pcre_find_bracket(cc, utf8, -1))
+     {
+     if (GET(cc, 1) == 0)
+       {
+       int fixed_length;
+       uschar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);
+       int end_op = *be;
+       *be = OP_END;
+       fixed_length = find_fixedlength(cc, re->options, TRUE, cd);
+       *be = end_op;
+       DPRINTF(("fixed length = %d\n", fixed_length));
+       if (fixed_length < 0)
+         {
+         errorcode = (fixed_length == -2)? ERR36 : ERR25;
+         break;
+         }
+       PUT(cc, 1, fixed_length);
+       }
+     cc += 1 + LINK_SIZE;
+     }
+   }
  /* Failed to compile, or error while post-processing */
  if (errorcode != 0)
-Line 6133 
 if (reqbyte >= 0 &&
+Line 6856 
 if (reqbyte >= 0 &&
  /* Print out the compiled data if debugging is enabled. This is never the
  case when building a production library. */
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  printf("Length = %d top_bracket = %d top_backref = %d\n",
    length, re->top_bracket, re->top_backref);
-Line 6171 
 if (code - codestart > length)
+Line 6893 
 if (code - codestart > length)
    if (errorcodeptr != NULL) *errorcodeptr = ERR23;
    return NULL;
    }
- #endif   /* DEBUG */
+ #endif   /* PCRE_DEBUG */
  return (pcre *)re;
  }

 Legend:



Removed from v.275
 


changed lines


 
Added in v.507
 Legend:



Removed from v.275
 


changed lines


 
Added in v.507
-Removed from v.275
+Added in v.507

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12