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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 349 by ph10,
Wed Jul  2 18:42:11 2008 UTC
+revision 504 by ph10,
Mon Mar  8 08:57:04 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-2008 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 97 
 are simple data values; negative values
+Line 98 
 are simple data values; negative values
  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 178 
 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 188 
 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 const verbitem verbs[] = {
    { 6, OP_ACCEPT },
-Line 178 
 length entry. The first three must be al
+Line 216 
 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 263 
 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 303 
 static const char error_texts[] =
+Line 346 
 static const char error_texts[] =
    "number is too big\0"
    "subpattern name expected\0"
    "digit expected after (?+\0"
-   "] is an invalid data character in JavaScript compatibility mode";
+   "] 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 322 
 For convenience, we use the same bit def
+Line 366 
 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 358 
 static const unsigned char digitab[] =
+Line 406 
 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 455 
 static const char *
+Line 506 
 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 503 
 if (c == 0) *errorcodeptr = ERR1;
+Line 558 
 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 524 
 else
+Line 579 
 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;
-Line 548 
 else
+Line 603 
 else
      (possibly recursive) subroutine calls, _not_ backreferences. Just return
      the -ESC_g code (cf \k). */
-     case 'g':
+     case CHAR_g:
-     if (ptr[1] == '<' || ptr[1] == '\'')
+     if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)
        {
        c = -ESC_g;
        break;
-Line 557 
 else
+Line 612 
 else
      /* 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 572 
 else
+Line 627 
 else
        }
      else braced = FALSE;
-     if (ptr[1] == '-')
+     if (ptr[1] == CHAR_MINUS)
        {
        negated = TRUE;
        ptr++;
-Line 581 
 else
+Line 636 
 else
      c = 0;
      while ((digitab[ptr[1]] & ctype_digit) != 0)
-       c = c * 10 + *(++ptr) - '0';
+       c = c * 10 + *(++ptr) - CHAR_0;
      if (c < 0)   /* Integer overflow */
        {
-Line 589 
 else
+Line 644 
 else
        break;
        }
-     if (braced && *(++ptr) != '}')
+     if (braced && *(++ptr) != CHAR_RIGHT_CURLY_BRACKET)
        {
        *errorcodeptr = ERR57;
        break;
-Line 626 
 else
+Line 681 
 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)    /* Integer overflow */
          {
          *errorcodeptr = ERR61;
-Line 652 
 else
+Line 707 
 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 665 
 else
+Line 720 
 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 676 
 else
+Line 731 
 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 686 
 else
+Line 741 
 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 714 
 else
+Line 769 
 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 730 
 else
+Line 785 
 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 738 
 else
+Line 793 
 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 804 
 if (c == 0) goto ERROR_RETURN;
+Line 859 
 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 815 
 if (c == '{')
+Line 870 
 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 883 
 is_counted_repeat(const uschar *p)
+Line 938 
 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 924 
 int max = -1;
+Line 979 
 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 934 
 if (min < 0 || min > 65535)
+Line 989 
 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 964 
 return p;
+Line 1019 
 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)
    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, compile_data *cd, 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 count = cd->bracount;
+ 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;
      }
-Line 1012 
 for (; *ptr != 0; ptr++)
+Line 1137 
 for (; *ptr != 0; ptr++)
    /* 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. */
+   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)
      {
      BOOL negate_class = FALSE;
      for (;;)
        {
-       int c = *(++ptr);
+       if (ptr[1] == CHAR_BACKSLASH)
-       if (c == '\\')
          {
-         if (ptr[1] == 'E') ptr++;
+         if (ptr[2] == CHAR_E)
-           else if (strncmp((const char *)ptr+1, "Q\\E", 3) == 0) ptr += 3;
+           ptr+= 2;
-             else break;
+         else if (strncmp((const char *)ptr+2,
+                  STR_Q STR_BACKSLASH STR_E, 3) == 0)
+           ptr += 4;
+         else
+           break;
          }
-       else if (!negate_class && c == '^')
+       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] == ']' && (cd->external_options & PCRE_JAVASCRIPT_COMPAT) == 0)
+     if (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET &&
+         (cd->external_options & PCRE_JAVASCRIPT_COMPAT) == 0)
        ptr++;
-     while (*(++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 1057 
 for (; *ptr != 0; ptr++)
+Line 1190 
 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;
+     }
+   else if (*ptr == CHAR_RIGHT_PARENTHESIS)
+     {
+     if (dup_parens && *count < hwm_count) *count = hwm_count;
+     *ptrptr = ptr;
+     return -1;
+     }
+   else if (*ptr == CHAR_VERTICAL_LINE && dup_parens)
+     {
+     if (*count > hwm_count) hwm_count = *count;
+     *count = start_count;
      }
+   }
+ FAIL_EXIT:
+ *ptrptr = ptr;
+ return -1;
+ }
-   ptr += 2;
-   if (*ptr == 'P') ptr++;                      /* Allow optional P */
-   /* We have to disambiguate (?<! and (?<= from (?<name> */
-   if ((*ptr != '<' || ptr[1] == '!' || ptr[1] == '=') &&
-        *ptr != '\'')
-     continue;
-   count++;
+ /*************************************************
+ *       Find forward referenced subpattern       *
+ *************************************************/
+ /* This function scans along a pattern's text looking for capturing
+ subpatterns, and counting them. If it finds a named pattern that matches the
+ name it is given, it returns its number. Alternatively, if the name is NULL, it
+ returns when it reaches a given numbered subpattern. This is used for forward
+ references to subpatterns. We used to be able to start this scan from the
+ current compiling point, using the current count value from cd->bracount, and
+ do it all in a single loop, but the addition of the possibility of duplicate
+ subpattern numbers means that we have to scan from the very start, in order to
+ take account of such duplicates, and to use a recursive function to keep track
+ of the different types of group.
-   if (name == NULL && count == lorn) return count;
+ Arguments:
-   term = *ptr++;
+   cd           compile background data
-   if (term == '<') term = '>';
+   name         name to seek, or NULL if seeking a numbered subpattern
-   thisname = ptr;
+   lorn         name length, or subpattern number if name is NULL
-   while (*ptr != term) ptr++;
+   xmode        TRUE if we are in /x mode
-   if (name != NULL && lorn == ptr - thisname &&
-       strncmp((const char *)name, (const char *)thisname, lorn) == 0)
+ Returns:       the number of the found subpattern, or -1 if not found
-     return count;
+ */
+ 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 1149 
 for (;;)
+Line 1325 
 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 1165 
 for (;;)
+Line 1343 
 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 1194 
 branch, check the length against that of
+Line 1383 
 branch, check the length against that of
  for (;;)
    {
    int d;
+   uschar *ce, *cs;
    register int op = *cc;
    switch (op)
      {
-Line 1201 
 for (;;)
+Line 1391 
 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 1224 
 for (;;)
+Line 1414 
 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 1237 
 for (;;)
+Line 1442 
 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 1260 
 for (;;)
+Line 1468 
 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 1274 
 for (;;)
+Line 1480 
 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 1356 
 for (;;)
+Line 1560 
 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 1384 
 for (;;)
+Line 1591 
 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 1450 
 for (;;)
+Line 1665 
 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 1543 
 for (;;)
+Line 1760 
 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 1566 
 Arguments:
+Line 1785 
 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 1581 
 for (code = first_significant_code(code
+Line 1802 
 for (code = first_significant_code(code
    const uschar *ccode;
    c = *code;
    /* Skip over forward assertions; the other assertions are skipped by
    first_significant_code() with a TRUE final argument. */
-Line 1601 
 for (code = first_significant_code(code
+Line 1822 
 for (code = first_significant_code(code
      c = *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. */
-Line 1609 
 for (code = first_significant_code(code
+Line 1852 
 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 1737 
 for (code = first_significant_code(code
+Line 1988 
 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 1765 
 Arguments:
+Line 2024 
 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 1821 
 int terminator;          /* Don't combin
+Line 2082 
 int terminator;          /* Don't combin
  terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
  for (++ptr; *ptr != 0; ptr++)
    {
-   if (*ptr == '\\' && ptr[1] == ']') ptr++; else
+   if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET) ptr++; else
      {
-     if (*ptr == ']') return FALSE;
+     if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
-     if (*ptr == terminator && ptr[1] == ']')
+     if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
        {
        *endptr = ptr;
        return TRUE;
-Line 2070 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2331 
 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 2082 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2343 
 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 2107 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2368 
 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 2118 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2379 
 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 2134 
 if (next >= 0) switch(op_code)
+Line 2396 
 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 2434 
 BOOL utf8 = FALSE;
+Line 2698 
 BOOL utf8 = FALSE;
  uschar *utf8_char = NULL;
  #endif
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  if (lengthptr != NULL) DPRINTF((">> start branch\n"));
  #endif
-Line 2493 
 for (;; ptr++)
+Line 2757 
 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 */
-Line 2555 
 for (;; ptr++)
+Line 2819 
 for (;; ptr++)
    if (inescq && c != 0)
      {
-     if (c == '\\' && ptr[1] == 'E')
+     if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)
        {
        inescq = FALSE;
        ptr++;
-Line 2581 
 for (;; ptr++)
+Line 2845 
 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 2597 
 for (;; ptr++)
+Line 2862 
 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 2622 
 for (;; ptr++)
+Line 2887 
 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 2645 
 for (;; ptr++)
+Line 2910 
 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 2654 
 for (;; ptr++)
+Line 2919 
 for (;; ptr++)
      *code++ = OP_CIRC;
      break;
-     case '$':
+     case CHAR_DOLLAR_SIGN:
      previous = NULL;
      *code++ = OP_DOLL;
      break;
-Line 2662 
 for (;; ptr++)
+Line 2927 
 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;
-Line 2686 
 for (;; ptr++)
+Line 2951 
 for (;; ptr++)
      In JavaScript compatibility mode, an isolated ']' causes an error. In
      default (Perl) mode, it is treated as a data character. */
-     case ']':
+     case CHAR_RIGHT_SQUARE_BRACKET:
      if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
        {
        *errorcodeptr = ERR64;
-Line 2694 
 for (;; ptr++)
+Line 2959 
 for (;; ptr++)
        }
      goto NORMAL_CHAR;
-     case '[':
+     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 ||
+          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 2715 
 for (;; ptr++)
+Line 2981 
 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;
        }
-Line 2731 
 for (;; ptr++)
+Line 3001 
 for (;; ptr++)
      that. In JS mode, [] must always fail, so generate OP_FAIL, whereas
      [^] must match any character, so generate OP_ALLANY. */
-     if (c ==']' && (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
+     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;
-Line 2796 
 for (;; ptr++)
+Line 3067 
 for (;; ptr++)
        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 2811 
 for (;; ptr++)
+Line 3082 
 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))
+            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 */
-Line 2900 
 for (;; ptr++)
+Line 3171 
 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 3136 
 for (;; ptr++)
+Line 3407 
 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 3146 
 for (;; ptr++)
+Line 3417 
 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 3186 
 for (;; ptr++)
+Line 3458 
 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 3196 
 for (;; ptr++)
+Line 3468 
 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 3219 
 for (;; ptr++)
+Line 3491 
 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 3366 
 for (;; ptr++)
+Line 3638 
 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 3511 
 we set the flag only if there is a liter
+Line 3783 
 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 3562 
 we set the flag only if there is a liter
+Line 3834 
 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 3683 
 we set the flag only if there is a liter
+Line 3955 
 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 3833 
 we set the flag only if there is a liter
+Line 4110 
 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 3971 
 we set the flag only if there is a liter
+Line 4253 
 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 4023 
 we set the flag only if there is a liter
+Line 4307 
 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 4108 
 we set the flag only if there is a liter
+Line 4393 
 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 4151 
 we set the flag only if there is a liter
+Line 4436 
 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 == OP_TYPEEXACT &&
+           ((tempcode[3] == OP_PROP || tempcode[3] == OP_NOTPROP)? 2 : 0);
-              (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 4174 
 we set the flag only if there is a liter
+Line 4468 
 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 4201 
 we set the flag only if there is a liter
+Line 4500 
 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 4210 
 we set the flag only if there is a liter
+Line 4509 
 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 4233 
 we set the flag only if there is a liter
+Line 4532 
 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 4247 
 we set the flag only if there is a liter
+Line 4557 
 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 4256 
 we set the flag only if there is a liter
+Line 4566 
 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 4268 
 we set the flag only if there is a liter
+Line 4578 
 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 4300 
 we set the flag only if there is a liter
+Line 4610 
 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 4312 
 we set the flag only if there is a liter
+Line 4623 
 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 4322 
 we set the flag only if there is a liter
+Line 4633 
 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 4355 
 we set the flag only if there is a liter
+Line 4666 
 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 4382 
 we set the flag only if there is a liter
+Line 4694 
 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 4394 
 we set the flag only if there is a liter
+Line 4706 
 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 4409 
 we set the flag only if there is a liter
+Line 4724 
 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, 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 4434 
 we set the flag only if there is a liter
+Line 4751 
 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 4444 
 we set the flag only if there is a liter
+Line 4761 
 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 4454 
 we set the flag only if there is a liter
+Line 4771 
 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;
-Line 4479 
 we set the flag only if there is a liter
+Line 4796 
 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 4499 
 we set the flag only if there is a liter
+Line 4816 
 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 4522 
 we set the flag only if there is a liter
+Line 4839 
 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 4557 
 we set the flag only if there is a liter
+Line 4874 
 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 4574 
 we set the flag only if there is a liter
+Line 4892 
 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 4607 
 we set the flag only if there is a liter
+Line 4926 
 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 4619 
 we set the flag only if there is a liter
+Line 4951 
 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 4710 
 we set the flag only if there is a liter
+Line 5075 
 we set the flag only if there is a liter
              recno = GET2(slot, 0);
              }
            else if ((recno =                /* Forward back reference */
-                     find_parens(ptr, cd, name, namelen,
+                     find_parens(cd, name, namelen,
                        (options & PCRE_EXTENDED) != 0)) <= 0)
              {
              *errorcodeptr = ERR15;
-Line 4726 
 we set the flag only if there is a liter
+Line 5091 
 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 = ')';
+           terminator = CHAR_RIGHT_PARENTHESIS;
            /* Come here from the \g<...> and \g'...' code (Oniguruma
            compatibility). However, the syntax has been checked to ensure that
-Line 4747 
 we set the flag only if there is a liter
+Line 5112 
 we set the flag only if there is a liter
            HANDLE_NUMERICAL_RECURSION:
-           if ((refsign = *ptr) == '+')
+           if ((refsign = *ptr) == CHAR_PLUS)
              {
              ptr++;
              if ((digitab[*ptr] & ctype_digit) == 0)
-Line 4756 
 we set the flag only if there is a liter
+Line 5121 
 we set the flag only if there is a liter
                goto FAILED;
                }
              }
-           else if (refsign == '-')
+           else if (refsign == CHAR_MINUS)
              {
              if ((digitab[ptr[1]] & ctype_digit) == 0)
                goto OTHER_CHAR_AFTER_QUERY;
-Line 4765 
 we set the flag only if there is a liter
+Line 5130 
 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 != terminator)
              {
-Line 4773 
 we set the flag only if there is a liter
+Line 5138 
 we set the flag only if there is a liter
              goto FAILED;
              }
-           if (refsign == '-')
+           if (refsign == CHAR_MINUS)
              {
              if (recno == 0)
                {
-Line 4787 
 we set the flag only if there is a liter
+Line 5152 
 we set the flag only if there is a liter
                goto FAILED;
                }
              }
-           else if (refsign == '+')
+           else if (refsign == CHAR_PLUS)
              {
              if (recno == 0)
                {
-Line 4814 
 we set the flag only if there is a liter
+Line 5179 
 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, NULL, recno,
+               if (find_parens(cd, NULL, recno,
                      (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 4835 
 we set the flag only if there is a liter
+Line 5206 
 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 4873 
 we set the flag only if there is a liter
+Line 5244 
 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 4920 
 we set the flag only if there is a liter
+Line 5291 
 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 5066 
 we set the flag only if there is a liter
+Line 5434 
 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 5164 
 we set the flag only if there is a liter
+Line 5532 
 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 5173 
 we set the flag only if there is a liter
+Line 5541 
 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 5202 
 we set the flag only if there is a liter
+Line 5571 
 we set the flag only if there is a liter
          {
          const uschar *p;
          save_hwm = cd->hwm;   /* Normally this is set when '(' is read */
-         terminator = (*(++ptr) == '<')? '>' : '\'';
+         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
-Line 5214 
 we set the flag only if there is a liter
+Line 5584 
 we set the flag only if there is a liter
          /* Test for a name */
-         if (ptr[1] != '+' && ptr[1] != '-')
+         if (ptr[1] != CHAR_PLUS && ptr[1] != CHAR_MINUS)
            {
            BOOL isnumber = TRUE;
            for (p = ptr + 1; *p != 0 && *p != terminator; p++)
-Line 5252 
 we set the flag only if there is a liter
+Line 5622 
 we set the flag only if there is a liter
        /* \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 5265 
 we set the flag only if there is a liter
+Line 5638 
 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 5274 
 we set the flag only if there is a liter
+Line 5648 
 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 5358 
 we set the flag only if there is a liter
+Line 5745 
 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 5456 
 uschar *code = *codeptr;
+Line 5843 
 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 5482 
 the code that abstracts option settings
+Line 5872 
 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 5526 
 for (;;)
+Line 5929 
 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 5576 
 for (;;)
+Line 5988 
 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 5603 
 for (;;)
+Line 6023 
 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 5624 
 for (;;)
+Line 6044 
 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 (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 == ')')
+     if ((options & PCRE_IMS) != oldims && *ptr == CHAR_RIGHT_PARENTHESIS)
        {
        *code++ = OP_OPT;
        *code++ = oldims;
-Line 5673 
 for (;;)
+Line 6114 
 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 5808 
 do {
+Line 6249 
 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 5826 
 do {
+Line 6295 
 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 5944 
 Returns:        pointer to compiled data
+Line 6415 
 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 5952 
 return pcre_compile2(pattern, options, N
+Line 6423 
 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 5961 
 int length = 1;  /* For final END opcode
+Line 6432 
 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 6006 
 if (erroroffset == NULL)
+Line 6475 
 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 6038 
 cd->fcc = tables + fcc_offset;
+Line 6483 
 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 6069 
 while (ptr[skipatstart] == '(' && ptr[sk
+Line 6526 
 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 6087 
 current code allows for fixed one- or tw
+Line 6561 
 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 6151 
 cd->end_pattern = (const uschar *)(patte
+Line 6625 
 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 6225 
 cd->start_code = codestart;
+Line 6700 
 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 6250 
 if debugging, leave the test till after
+Line 6727 
 if debugging, leave the test till after
  *code++ = OP_END;
- #ifndef DEBUG
+ #ifndef PCRE_DEBUG
  if (code - codestart > length) errorcode = ERR23;
  #endif
-Line 6263 
 while (errorcode == 0 && cd->hwm > cwork
+Line 6740 
 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 6273 
 subpattern. */
+Line 6750 
 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 6333 
 if (reqbyte >= 0 &&
+Line 6851 
 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 6371 
 if (code - codestart > length)
+Line 6888 
 if (code - codestart > length)
    if (errorcodeptr != NULL) *errorcodeptr = ERR23;
    return NULL;
    }
- #endif   /* DEBUG */
+ #endif   /* PCRE_DEBUG */
  return (pcre *)re;
  }

 Legend:



Removed from v.349
 


changed lines


 
Added in v.504
 Legend:



Removed from v.349
 


changed lines


 
Added in v.504
-Removed from v.349
+Added in v.504

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12