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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 392 by ph10,
Tue Mar 17 21:30:30 2009 UTC
+revision 530 by ph10,
Tue Jun  1 13:42:06 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-2009 University of Cambridge
+            Copyright (c) 1997-2010 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 53 
 supporting internal functions that are n
  #include "pcre_internal.h"
- /* When DEBUG is defined, we need the pcre_printint() function, which is also
+ /* When PCRE_DEBUG is defined, we need the pcre_printint() function, which is
- used by pcretest. DEBUG is not defined when building a production library. */
+ also used by pcretest. PCRE_DEBUG is not defined when building a production
+ library. */
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  #include "pcre_printint.src"
  #endif
-Line 91 
 is 4 there is plenty of room. */
+Line 92 
 is 4 there is plenty of room. */
  #define COMPILE_WORK_SIZE (4096)
+ /* The overrun tests check for a slightly smaller size so that they detect the
+ overrun before it actually does run off the end of the data block. */
+ #define WORK_SIZE_CHECK (COMPILE_WORK_SIZE - 100)
  /* Table for handling escaped characters in the range '0'-'z'. Positive returns
  are simple data values; negative values are for special things like \d and so
-Line 118 
 static const short int escapes[] = {
+Line 124 
 static const short int escapes[] = {
       -ESC_H,                  0,
 ,                       -ESC_K,
 ,                       0,
-,                       0,
+      -ESC_N,                  0,
       -ESC_P,                  -ESC_Q,
       -ESC_R,                  -ESC_S,
 ,                       0,
-Line 165 
 static const short int escapes[] = {
+Line 171 
 static const short int escapes[] = {
  /*  B8 */     0,     0,      0,       0,      0,   ']',    '=',    '-',
  /*  C0 */   '{',-ESC_A, -ESC_B,  -ESC_C, -ESC_D,-ESC_E,      0, -ESC_G,
  /*  C8 */-ESC_H,     0,      0,       0,      0,     0,      0,      0,
- /*  D0 */   '}',     0, -ESC_K,       0,      0,     0,      0, -ESC_P,
+ /*  D0 */   '}',     0, -ESC_K,       0,      0,-ESC_N,      0, -ESC_P,
  /*  D8 */-ESC_Q,-ESC_R,      0,       0,      0,     0,      0,      0,
  /*  E0 */  '\\',     0, -ESC_S,       0,      0,-ESC_V, -ESC_W, -ESC_X,
  /*  E8 */     0,-ESC_Z,      0,       0,      0,     0,      0,      0,
-Line 182 
 string is built from string macros so th
+Line 188 
 string is built from string macros so th
  platforms. */
  typedef struct verbitem {
-   int   len;
+   int   len;                 /* Length of verb name */
-   int   op;
+   int   op;                  /* Op when no arg, or -1 if arg mandatory */
+   int   op_arg;              /* Op when arg present, or -1 if not allowed */
  } verbitem;
  static const char verbnames[] =
+   "\0"                       /* Empty name is a shorthand for MARK */
+   STRING_MARK0
    STRING_ACCEPT0
    STRING_COMMIT0
    STRING_F0
-Line 196 
 static const char verbnames[] =
+Line 205 
 static const char verbnames[] =
    STRING_THEN;
  static const verbitem verbs[] = {
-   { 6, OP_ACCEPT },
+   { 0, -1,        OP_MARK },
-   { 6, OP_COMMIT },
+   { 4, -1,        OP_MARK },
-   { 1, OP_FAIL },
+   { 6, OP_ACCEPT, -1 },
-   { 4, OP_FAIL },
+   { 6, OP_COMMIT, -1 },
-   { 5, OP_PRUNE },
+   { 1, OP_FAIL,   -1 },
-   { 4, OP_SKIP  },
+   { 4, OP_FAIL,   -1 },
-   { 4, OP_THEN  }
+   { 5, OP_PRUNE,  OP_PRUNE_ARG },
+   { 4, OP_SKIP,   OP_SKIP_ARG  },
+   { 4, OP_THEN,   OP_THEN_ARG  }
  };
  static const int verbcount = sizeof(verbs)/sizeof(verbitem);
-Line 250 
 static const int posix_class_maps[] = {
+Line 261 
 static const int posix_class_maps[] = {
    cbit_xdigit,-1,          0              /* xdigit */
  };
+ /* Table of substitutes for \d etc when PCRE_UCP is set. The POSIX class
+ substitutes must be in the order of the names, defined above, and there are
+ both positive and negative cases. NULL means no substitute. */
+ #ifdef SUPPORT_UCP
+ static const uschar *substitutes[] = {
+   (uschar *)"\\P{Nd}",    /* \D */
+   (uschar *)"\\p{Nd}",    /* \d */
+   (uschar *)"\\P{Xsp}",   /* \S */       /* NOTE: Xsp is Perl space */
+   (uschar *)"\\p{Xsp}",   /* \s */
+   (uschar *)"\\P{Xwd}",   /* \W */
+   (uschar *)"\\p{Xwd}"    /* \w */
+ };
+ static const uschar *posix_substitutes[] = {
+   (uschar *)"\\p{L}",     /* alpha */
+   (uschar *)"\\p{Ll}",    /* lower */
+   (uschar *)"\\p{Lu}",    /* upper */
+   (uschar *)"\\p{Xan}",   /* alnum */
+   NULL,                   /* ascii */
+   (uschar *)"\\h",        /* blank */
+   NULL,                   /* cntrl */
+   (uschar *)"\\p{Nd}",    /* digit */
+   NULL,                   /* graph */
+   NULL,                   /* print */
+   NULL,                   /* punct */
+   (uschar *)"\\p{Xps}",   /* space */    /* NOTE: Xps is POSIX space */
+   (uschar *)"\\p{Xwd}",   /* word */
+   NULL,                   /* xdigit */
+   /* Negated cases */
+   (uschar *)"\\P{L}",     /* ^alpha */
+   (uschar *)"\\P{Ll}",    /* ^lower */
+   (uschar *)"\\P{Lu}",    /* ^upper */
+   (uschar *)"\\P{Xan}",   /* ^alnum */
+   NULL,                   /* ^ascii */
+   (uschar *)"\\H",        /* ^blank */
+   NULL,                   /* ^cntrl */
+   (uschar *)"\\P{Nd}",    /* ^digit */
+   NULL,                   /* ^graph */
+   NULL,                   /* ^print */
+   NULL,                   /* ^punct */
+   (uschar *)"\\P{Xps}",   /* ^space */   /* NOTE: Xps is POSIX space */
+   (uschar *)"\\P{Xwd}",   /* ^word */
+   NULL                    /* ^xdigit */
+ };
+ #define POSIX_SUBSIZE (sizeof(posix_substitutes)/sizeof(uschar *))
+ #endif
  #define STRING(a)  # a
  #define XSTRING(s) STRING(s)
-Line 262 
 the number of relocations needed when a
+Line 320 
 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 309 
 static const char error_texts[] =
+Line 371 
 static const char error_texts[] =
    /* 35 */
    "invalid condition (?(0)\0"
    "\\C not allowed in lookbehind assertion\0"
-   "PCRE does not support \\L, \\l, \\N, \\U, or \\u\0"
+   "PCRE does not support \\L, \\l, \\N{name}, \\U, or \\u\0"
    "number after (?C is > 255\0"
    "closing ) for (?C expected\0"
    /* 40 */
-Line 335 
 static const char error_texts[] =
+Line 397 
 static const char error_texts[] =
    "inconsistent NEWLINE options\0"
    "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
    "a numbered reference must not be zero\0"
-   "(*VERB) with an argument is not supported\0"
+   "an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)\0"
    /* 60 */
    "(*VERB) not recognized\0"
    "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"
+   "(*MARK) must have an argument\0"
+   "this version of PCRE is not compiled with PCRE_UCP support\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 500 
 static const char *
+Line 566 
 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 571 
 else
+Line 641 
 else
      case CHAR_l:
      case CHAR_L:
-     case CHAR_N:
      case CHAR_u:
      case CHAR_U:
      *errorcodeptr = ERR37;
-Line 809 
 else
+Line 878 
 else
      }
    }
+ /* Perl supports \N{name} for character names, as well as plain \N for "not
+ newline". PCRE does not support \N{name}. */
+ if (c == -ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET)
+   *errorcodeptr = ERR37;
+ /* If PCRE_UCP is set, we change the values for \d etc. */
+ if ((options & PCRE_UCP) != 0 && c <= -ESC_D && c >= -ESC_w)
+   c -= (ESC_DU - ESC_D);
+ /* Set the pointer to the final character before returning. */
  *ptrptr = ptr;
  return c;
  }
-Line 1009 
 return p;
+Line 1091 
 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 == CHAR_BACKSLASH)
      {
-     if (*(++ptr) == 0) return -1;
+     if (*(++ptr) == 0) goto FAIL_EXIT;
      if (*ptr == CHAR_Q) for (;;)
        {
        while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};
-       if (*ptr == 0) return -1;
+       if (*ptr == 0) goto FAIL_EXIT;
        if (*(++ptr) == CHAR_E) break;
        }
      continue;
-Line 1065 
 for (; *ptr != 0; ptr++)
+Line 1217 
 for (; *ptr != 0; ptr++)
      BOOL negate_class = FALSE;
      for (;;)
        {
-       int c = *(++ptr);
+       if (ptr[1] == CHAR_BACKSLASH)
-       if (c == CHAR_BACKSLASH)
          {
-         if (ptr[1] == CHAR_E)
+         if (ptr[2] == CHAR_E)
-           ptr++;
+           ptr+= 2;
-         else if (strncmp((const char *)ptr+1,
+         else if (strncmp((const char *)ptr+2,
                   STR_Q STR_BACKSLASH STR_E, 3) == 0)
-           ptr += 3;
+           ptr += 4;
          else
            break;
          }
-       else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT)
+       else if (!negate_class && ptr[1] == CHAR_CIRCUMFLEX_ACCENT)
+         {
          negate_class = TRUE;
+         ptr++;
+         }
        else break;
        }
-Line 1093 
 for (; *ptr != 0; ptr++)
+Line 1247 
 for (; *ptr != 0; ptr++)
        if (*ptr == 0) return -1;
        if (*ptr == CHAR_BACKSLASH)
          {
-         if (*(++ptr) == 0) return -1;
+         if (*(++ptr) == 0) goto FAIL_EXIT;
          if (*ptr == CHAR_Q) for (;;)
            {
            while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};
-           if (*ptr == 0) return -1;
+           if (*ptr == 0) goto FAIL_EXIT;
            if (*(++ptr) == CHAR_E) break;
            }
          continue;
-Line 1111 
 for (; *ptr != 0; ptr++)
+Line 1265 
 for (; *ptr != 0; ptr++)
    if (xmode && *ptr == CHAR_NUMBER_SIGN)
      {
      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 != CHAR_LEFT_PARENTHESIS) continue;
+   if (*ptr == CHAR_LEFT_PARENTHESIS)
-   if (ptr[1] != CHAR_QUESTION_MARK && ptr[1] != CHAR_ASTERISK)
      {
-     count++;
+     int rc = find_parens_sub(&ptr, cd, name, lorn, xmode, count);
-     if (name == NULL && count == lorn) return count;
+     if (rc > 0) return rc;
-     continue;
+     if (*ptr == 0) goto FAIL_EXIT;
      }
-   ptr += 2;
+   else if (*ptr == CHAR_RIGHT_PARENTHESIS)
-   if (*ptr == CHAR_P) ptr++;                      /* Allow optional P */
+     {
+     if (dup_parens && *count < hwm_count) *count = hwm_count;
+     *ptrptr = ptr;
+     return -1;
+     }
-   /* We have to disambiguate (?<! and (?<= from (?<name> */
+   else if (*ptr == CHAR_VERTICAL_LINE && dup_parens)
+     {
+     if (*count > hwm_count) hwm_count = *count;
+     *count = start_count;
+     }
+   }
-   if ((*ptr != CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_EXCLAMATION_MARK ||
+ FAIL_EXIT:
-       ptr[1] == CHAR_EQUALS_SIGN) && *ptr != CHAR_APOSTROPHE)
+ *ptrptr = ptr;
-     continue;
+ return -1;
+ }
+ /*************************************************
+ *       Find forward referenced subpattern       *
+ *************************************************/
+ /* This function scans along a pattern's text looking for capturing
+ subpatterns, and counting them. If it finds a named pattern that matches the
+ name it is given, it returns its number. Alternatively, if the name is NULL, it
+ returns when it reaches a given numbered subpattern. This is used for forward
+ references to subpatterns. We used to be able to start this scan from the
+ current compiling point, using the current count value from cd->bracount, and
+ do it all in a single loop, but the addition of the possibility of duplicate
+ subpattern numbers means that we have to scan from the very start, in order to
+ take account of such duplicates, and to use a recursive function to keep track
+ of the different types of group.
+ Arguments:
+   cd           compile background data
+   name         name to seek, or NULL if seeking a numbered subpattern
+   lorn         name length, or subpattern number if name is NULL
+   xmode        TRUE if we are in /x mode
+ Returns:       the number of the found subpattern, or -1 if not found
+ */
-   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. */
-   if (name == NULL && count == lorn) return count;
+ for (;;)
-   term = *ptr++;
+   {
-   if (term == CHAR_LESS_THAN_SIGN) term = CHAR_GREATER_THAN_SIGN;
+   rc = find_parens_sub(&ptr, cd, name, lorn, xmode, &count);
-   thisname = ptr;
+   if (rc > 0 || *ptr++ == 0) break;
-   while (*ptr != term) ptr++;
-   if (name != NULL && lorn == ptr - thisname &&
-       strncmp((const char *)name, (const char *)thisname, lorn) == 0)
-     return count;
    }
- return -1;
+ return rc;
  }
  /*************************************************
  *      Find first significant op code            *
  *************************************************/
-Line 1200 
 for (;;)
+Line 1397 
 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 1216 
 for (;;)
+Line 1415 
 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 1245 
 branch, check the length against that of
+Line 1455 
 branch, check the length against that of
  for (;;)
    {
    int d;
+   uschar *ce, *cs;
    register int op = *cc;
    switch (op)
      {
-Line 1252 
 for (;;)
+Line 1463 
 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 1275 
 for (;;)
+Line 1486 
 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 1288 
 for (;;)
+Line 1514 
 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 1311 
 for (;;)
+Line 1540 
 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 1325 
 for (;;)
+Line 1552 
 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 1407 
 for (;;)
+Line 1632 
 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 1435 
 for (;;)
+Line 1663 
 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 1446 
 for (;;)
+Line 1682 
 for (;;)
    /* Otherwise, we can get the item's length from the table, except that for
    repeated character types, we have to test for \p and \P, which have an extra
-   two bytes of parameters. */
+   two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
+   must add in its length. */
    else
      {
-Line 1470 
 for (;;)
+Line 1707 
 for (;;)
        case OP_TYPEPOSUPTO:
        if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
        break;
+       case OP_MARK:
+       case OP_PRUNE_ARG:
+       case OP_SKIP_ARG:
+       case OP_THEN_ARG:
+       code += code[1];
+       break;
        }
      /* Add in the fixed length from the table */
-Line 1541 
 for (;;)
+Line 1785 
 for (;;)
    /* Otherwise, we can get the item's length from the table, except that for
    repeated character types, we have to test for \p and \P, which have an extra
-   two bytes of parameters. */
+   two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
+   must add in its length. */
    else
      {
-Line 1565 
 for (;;)
+Line 1810 
 for (;;)
        case OP_TYPEEXACT:
        if (code[3] == OP_PROP || code[3] == OP_NOTPROP) code += 2;
        break;
+       case OP_MARK:
+       case OP_PRUNE_ARG:
+       case OP_SKIP_ARG:
+       case OP_THEN_ARG:
+       code += code[1];
+       break;
        }
      /* Add in the fixed length from the table */
-Line 1621 
 Arguments:
+Line 1873 
 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 1657 
 for (code = first_significant_code(code
+Line 1911 
 for (code = first_significant_code(code
      continue;
      }
+   /* For a recursion/subroutine call, if its end has been reached, which
+   implies a subroutine call, we can scan it. */
+   if (c == OP_RECURSE)
+     {
+     BOOL empty_branch = FALSE;
+     const uschar *scode = cd->start_code + GET(code, 1);
+     if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
+     do
+       {
+       if (could_be_empty_branch(scode, endcode, utf8, cd))
+         {
+         empty_branch = TRUE;
+         break;
+         }
+       scode += GET(scode, 1);
+       }
+     while (*scode == OP_ALT);
+     if (!empty_branch) return FALSE;  /* All branches are non-empty */
+     continue;
+     }
    /* For other groups, scan the branches. */
    if (c == OP_BRA || c == OP_CBRA || c == OP_ONCE || c == OP_COND)
-Line 1664 
 for (code = first_significant_code(code
+Line 1940 
 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 1792 
 for (code = first_significant_code(code
+Line 2076 
 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
+     /* MARK, and PRUNE/SKIP/THEN with an argument must skip over the argument
+     string. */
+     case OP_MARK:
+     case OP_PRUNE_ARG:
+     case OP_SKIP_ARG:
+     case OP_THEN_ARG:
+     code += code[1];
+     break;
+     /* None of the remaining opcodes are required to match a character. */
+     default:
+     break;
      }
    }
-Line 1820 
 Arguments:
+Line 2122 
 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 2012 
 auto_callout(uschar *code, const uschar
+Line 2316 
 auto_callout(uschar *code, const uschar
  {
  *code++ = OP_CALLOUT;
  *code++ = 255;
- PUT(code, 0, ptr - cd->start_pattern);  /* Pattern offset */
+ PUT(code, 0, (int)(ptr - cd->start_pattern));  /* Pattern offset */
- PUT(code, LINK_SIZE, 0);                /* Default length */
+ PUT(code, LINK_SIZE, 0);                       /* Default length */
  return code + 2*LINK_SIZE;
  }
-Line 2038 
 Returns:             nothing
+Line 2342 
 Returns:             nothing
  static void
  complete_callout(uschar *previous_callout, const uschar *ptr, compile_data *cd)
  {
- int length = ptr - cd->start_pattern - GET(previous_callout, 2);
+ int length = (int)(ptr - cd->start_pattern - GET(previous_callout, 2));
  PUT(previous_callout, 2 + LINK_SIZE, length);
  }
-Line 2240 
 if (next >= 0) switch(op_code)
+Line 2544 
 if (next >= 0) switch(op_code)
    else
  #endif  /* SUPPORT_UTF8 */
    return (item == cd->fcc[next]);  /* Non-UTF-8 mode */
+   /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not* set.
+   When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
    case OP_DIGIT:
    return next > 127 || (cd->ctypes[next] & ctype_digit) == 0;
-Line 2282 
 if (next >= 0) switch(op_code)
+Line 2589 
 if (next >= 0) switch(op_code)
      case 0x202f:
      case 0x205f:
      case 0x3000:
-     return op_code != OP_HSPACE;
+     return op_code == OP_NOT_HSPACE;
      default:
-     return op_code == OP_HSPACE;
+     return op_code != OP_NOT_HSPACE;
      }
+   case OP_ANYNL:
    case OP_VSPACE:
    case OP_NOT_VSPACE:
    switch(next)
-Line 2298 
 if (next >= 0) switch(op_code)
+Line 2606 
 if (next >= 0) switch(op_code)
      case 0x85:
      case 0x2028:
      case 0x2029:
-     return op_code != OP_VSPACE;
+     return op_code == OP_NOT_VSPACE;
      default:
-     return op_code == OP_VSPACE;
+     return op_code != OP_NOT_VSPACE;
      }
    default:
-Line 2308 
 if (next >= 0) switch(op_code)
+Line 2616 
 if (next >= 0) switch(op_code)
    }
- /* Handle the case when the next item is \d, \s, etc. */
+ /* Handle the case when the next item is \d, \s, etc. Note that when PCRE_UCP
+ is set, \d turns into ESC_du rather than ESC_d, etc., so ESC_d etc. are
+ generated only when PCRE_UCP is *not* set, that is, when only ASCII
+ characteristics are recognized. */
  switch(op_code)
    {
-Line 2387 
 switch(op_code)
+Line 2698 
 switch(op_code)
    case OP_DIGIT:
    return next == -ESC_D || next == -ESC_s || next == -ESC_W ||
-          next == -ESC_h || next == -ESC_v;
+          next == -ESC_h || next == -ESC_v || next == -ESC_R;
    case OP_NOT_DIGIT:
    return next == -ESC_d;
    case OP_WHITESPACE:
-   return next == -ESC_S || next == -ESC_d || next == -ESC_w;
+   return next == -ESC_S || next == -ESC_d || next == -ESC_w || next == -ESC_R;
    case OP_NOT_WHITESPACE:
    return next == -ESC_s || next == -ESC_h || next == -ESC_v;
    case OP_HSPACE:
-   return next == -ESC_S || next == -ESC_H || next == -ESC_d || next == -ESC_w;
+   return next == -ESC_S || next == -ESC_H || next == -ESC_d ||
+          next == -ESC_w || next == -ESC_v || next == -ESC_R;
    case OP_NOT_HSPACE:
    return next == -ESC_h;
    /* Can't have \S in here because VT matches \S (Perl anomaly) */
+   case OP_ANYNL:
    case OP_VSPACE:
    return next == -ESC_V || next == -ESC_d || next == -ESC_w;
    case OP_NOT_VSPACE:
-   return next == -ESC_v;
+   return next == -ESC_v || next == -ESC_R;
    case OP_WORDCHAR:
-   return next == -ESC_W || next == -ESC_s || next == -ESC_h || next == -ESC_v;
+   return next == -ESC_W || next == -ESC_s || next == -ESC_h ||
+          next == -ESC_v || next == -ESC_R;
    case OP_NOT_WORDCHAR:
    return next == -ESC_w || next == -ESC_d;
-Line 2476 
 BOOL inescq = FALSE;
+Line 2790 
 BOOL inescq = FALSE;
  BOOL groupsetfirstbyte = FALSE;
  const uschar *ptr = *ptrptr;
  const uschar *tempptr;
+ const uschar *nestptr = NULL;
  uschar *previous = NULL;
  uschar *previous_callout = NULL;
  uschar *save_hwm = NULL;
-Line 2492 
 BOOL utf8 = FALSE;
+Line 2807 
 BOOL utf8 = FALSE;
  uschar *utf8_char = NULL;
  #endif
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  if (lengthptr != NULL) DPRINTF((">> start branch\n"));
  #endif
-Line 2546 
 for (;; ptr++)
+Line 2861 
 for (;; ptr++)
    c = *ptr;
+   /* If we are at the end of a nested substitution, revert to the outer level
+   string. Nesting only happens one level deep. */
+   if (c == 0 && nestptr != NULL)
+     {
+     ptr = nestptr;
+     nestptr = NULL;
+     c = *ptr;
+     }
    /* If we are in the pre-compile phase, accumulate the length used for the
    previous cycle of this loop. */
    if (lengthptr != NULL)
      {
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
      if (code > cd->hwm) cd->hwm = code;                 /* High water info */
  #endif
-     if (code > cd->start_workspace + COMPILE_WORK_SIZE) /* Check for overrun */
+     if (code > cd->start_workspace + WORK_SIZE_CHECK)   /* Check for overrun */
        {
        *errorcodeptr = ERR52;
        goto FAILED;
-Line 2576 
 for (;; ptr++)
+Line 2901 
 for (;; ptr++)
        goto FAILED;
        }
-     *lengthptr += code - last_code;
+     *lengthptr += (int)(code - last_code);
      DPRINTF(("length=%d added %d c=%c\n", *lengthptr, code - last_code, c));
      /* If "previous" is set and it is not at the start of the work space, move
-Line 2603 
 for (;; ptr++)
+Line 2928 
 for (;; ptr++)
    /* In the real compile phase, just check the workspace used by the forward
    reference list. */
-   else if (cd->hwm > cd->start_workspace + COMPILE_WORK_SIZE)
+   else if (cd->hwm > cd->start_workspace + WORK_SIZE_CHECK)
      {
      *errorcodeptr = ERR52;
      goto FAILED;
-Line 2694 
 for (;; ptr++)
+Line 3019 
 for (;; ptr++)
          *errorcodeptr = ERR20;
          goto FAILED;
          }
-       *lengthptr += code - last_code;   /* To include callout length */
+       *lengthptr += (int)(code - last_code);   /* To include callout length */
        DPRINTF((">> end branch\n"));
        }
      return TRUE;
-Line 2843 
 for (;; ptr++)
+Line 3168 
 for (;; ptr++)
          {                           /* Braces are required because the */
          GETCHARLEN(c, ptr, ptr);    /* macro generates multiple statements */
          }
        /* In the pre-compile phase, accumulate the length of any UTF-8 extra
        data and reset the pointer. This is so that very large classes that
        contain a zillion UTF-8 characters no longer overwrite the work space
-Line 2899 
 for (;; ptr++)
+Line 3224 
 for (;; ptr++)
            ptr++;
            }
-         posix_class = check_posix_name(ptr, tempptr - ptr);
+         posix_class = check_posix_name(ptr, (int)(tempptr - ptr));
          if (posix_class < 0)
            {
            *errorcodeptr = ERR30;
-Line 2912 
 for (;; ptr++)
+Line 3237 
 for (;; ptr++)
          if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
            posix_class = 0;
-         /* We build the bit map for the POSIX class in a chunk of local store
+         /* When PCRE_UCP is set, some of the POSIX classes are converted to
-         because we may be adding and subtracting from it, and we don't want to
+         different escape sequences that use Unicode properties. */
-         subtract bits that may be in the main map already. At the end we or the
-         result into the bit map that is being built. */
+ #ifdef SUPPORT_UCP
+         if ((options & PCRE_UCP) != 0)
+           {
+           int pc = posix_class + ((local_negate)? POSIX_SUBSIZE/2 : 0);
+           if (posix_substitutes[pc] != NULL)
+             {
+             nestptr = tempptr + 1;
+             ptr = posix_substitutes[pc] - 1;
+             continue;
+             }
+           }
+ #endif
+         /* In the non-UCP case, we build the bit map for the POSIX class in a
+         chunk of local store because we may be adding and subtracting from it,
+         and we don't want to subtract bits that may be in the main map already.
+         At the end we or the result into the bit map that is being built. */
          posix_class *= 3;
-Line 2960 
 for (;; ptr++)
+Line 3300 
 for (;; ptr++)
        /* Backslash may introduce a single character, or it may introduce one
        of the specials, which just set a flag. The sequence \b is a special
-       case. Inside a class (and only there) it is treated as backspace.
+       case. Inside a class (and only there) it is treated as backspace. We
-       Elsewhere it marks a word boundary. Other escapes have preset maps ready
+       assume that other escapes have more than one character in them, so set
-       to 'or' into the one we are building. We assume they have more than one
+       class_charcount bigger than one. Unrecognized escapes fall through and
-       character in them, so set class_charcount bigger than one. */
+       are either treated as literal characters (by default), or are faulted if
+       PCRE_EXTRA is set. */
        if (c == CHAR_BACKSLASH)
          {
          c = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
          if (*errorcodeptr != 0) goto FAILED;
-         if (-c == ESC_b) c = CHAR_BS;       /* \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 = CHAR_X;   /* \X is literal X 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] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
-Line 2989 
 for (;; ptr++)
+Line 3328 
 for (;; ptr++)
            register const uschar *cbits = cd->cbits;
            class_charcount += 2;     /* Greater than 1 is what matters */
-           /* Save time by not doing this in the pre-compile phase. */
+           switch (-c)
-           if (lengthptr == NULL) switch (-c)
              {
+ #ifdef SUPPORT_UCP
+             case ESC_du:     /* These are the values given for \d etc */
+             case ESC_DU:     /* when PCRE_UCP is set. We replace the */
+             case ESC_wu:     /* escape sequence with an appropriate \p */
+             case ESC_WU:     /* or \P to test Unicode properties instead */
+             case ESC_su:     /* of the default ASCII testing. */
+             case ESC_SU:
+             nestptr = ptr;
+             ptr = substitutes[-c - ESC_DU] - 1;  /* Just before substitute */
+             class_charcount -= 2;                /* Undo! */
+             continue;
+ #endif
              case ESC_d:
              for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];
              continue;
-Line 3022 
 for (;; ptr++)
+Line 3371 
 for (;; ptr++)
              classbits[1] |= 0x08;    /* Perl 5.004 onwards omits VT from \s */
              continue;
-             default:    /* Not recognized; fall through */
+             case ESC_h:
-             break;      /* Need "default" setting to stop compiler warning. */
-             }
-           /* In the pre-compile phase, just do the recognition. */
-           else if (c == -ESC_d || c == -ESC_D || c == -ESC_w ||
-                    c == -ESC_W || c == -ESC_s || c == -ESC_S) continue;
-           /* We need to deal with \H, \h, \V, and \v in both phases because
-           they use extra memory. */
-           if (-c == ESC_h)
-             {
              SETBIT(classbits, 0x09); /* VT */
              SETBIT(classbits, 0x20); /* SPACE */
              SETBIT(classbits, 0xa0); /* NSBP */
-Line 3059 
 for (;; ptr++)
+Line 3395 
 for (;; ptr++)
                }
  #endif
              continue;
-             }
-           if (-c == ESC_H)
+             case ESC_H:
-             {
              for (c = 0; c < 32; c++)
                {
                int x = 0xff;
-Line 3104 
 for (;; ptr++)
+Line 3438 
 for (;; ptr++)
                }
  #endif
              continue;
-             }
-           if (-c == ESC_v)
+             case ESC_v:
-             {
              SETBIT(classbits, 0x0a); /* LF */
              SETBIT(classbits, 0x0b); /* VT */
              SETBIT(classbits, 0x0c); /* FF */
-Line 3123 
 for (;; ptr++)
+Line 3455 
 for (;; ptr++)
                }
  #endif
              continue;
-             }
-           if (-c == ESC_V)
+             case ESC_V:
-             {
              for (c = 0; c < 32; c++)
                {
                int x = 0xff;
-Line 3156 
 for (;; ptr++)
+Line 3486 
 for (;; ptr++)
                }
  #endif
              continue;
-             }
-           /* We need to deal with \P and \p in both phases. */
  #ifdef SUPPORT_UCP
-           if (-c == ESC_p || -c == ESC_P)
+             case ESC_p:
-             {
+             case ESC_P:
-             BOOL negated;
+               {
-             int pdata;
+               BOOL negated;
-             int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
+               int pdata;
-             if (ptype < 0) goto FAILED;
+               int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
-             class_utf8 = TRUE;
+               if (ptype < 0) goto FAILED;
-             *class_utf8data++ = ((-c == ESC_p) != negated)?
+               class_utf8 = TRUE;
-               XCL_PROP : XCL_NOTPROP;
+               *class_utf8data++ = ((-c == ESC_p) != negated)?
-             *class_utf8data++ = ptype;
+                 XCL_PROP : XCL_NOTPROP;
-             *class_utf8data++ = pdata;
+               *class_utf8data++ = ptype;
-             class_charcount -= 2;   /* Not a < 256 character */
+               *class_utf8data++ = pdata;
-             continue;
+               class_charcount -= 2;   /* Not a < 256 character */
-             }
+               continue;
+               }
  #endif
-           /* Unrecognized escapes are faulted if PCRE is running in its
+             /* Unrecognized escapes are faulted if PCRE is running in its
-           strict mode. By default, for compatibility with Perl, they are
+             strict mode. By default, for compatibility with Perl, they are
-           treated as literals. */
+             treated as literals. */
-           if ((options & PCRE_EXTRA) != 0)
+             default:
-             {
+             if ((options & PCRE_EXTRA) != 0)
-             *errorcodeptr = ERR7;
+               {
-             goto FAILED;
+               *errorcodeptr = ERR7;
+               goto FAILED;
+               }
+             class_charcount -= 2;  /* Undo the default count from above */
+             c = *ptr;              /* Get the final character and fall through */
+             break;
              }
-           class_charcount -= 2;  /* Undo the default count from above */
-           c = *ptr;              /* Get the final character and fall through */
            }
          /* Fall through if we have a single character (c >= 0). This may be
-Line 3257 
 for (;; ptr++)
+Line 3587 
 for (;; ptr++)
            d = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
            if (*errorcodeptr != 0) goto FAILED;
-           /* \b is backspace; \X is literal X; \R is literal R; any other
+           /* \b is backspace; any other special means the '-' was literal */
-           special means the '-' was literal */
            if (d < 0)
              {
-             if (d == -ESC_b) d = CHAR_BS;
+             if (d == -ESC_b) d = CHAR_BS; else
-             else if (d == -ESC_X) d = CHAR_X;
-             else if (d == -ESC_R) d = CHAR_R; else
                {
                ptr = oldptr;
                goto LONE_SINGLE_CHARACTER;  /* A few lines below */
-Line 3430 
 for (;; ptr++)
+Line 3757 
 for (;; ptr++)
          }
        }
-     /* Loop until ']' reached. This "while" is the end of the "do" above. */
+     /* Loop until ']' reached. This "while" is the end of the "do" far above.
+     If we are at the end of an internal nested string, revert to the outer
+     string. */
+     while (((c = *(++ptr)) != 0 ||
+            (nestptr != NULL &&
+              (ptr = nestptr, nestptr = NULL, c = *(++ptr)) != 0)) &&
+            (c != CHAR_RIGHT_SQUARE_BRACKET || inescq));
-     while ((c = *(++ptr)) != 0 && (c != CHAR_RIGHT_SQUARE_BRACKET || inescq));
+     /* Check for missing terminating ']' */
-     if (c == 0)                          /* Missing terminating ']' */
+     if (c == 0)
        {
        *errorcodeptr = ERR6;
        goto FAILED;
        }
- /* This code has been disabled because it would mean that \s counts as
- an explicit \r or \n reference, and that's not really what is wanted. Now
- we set the flag only if there is a literal "\r" or "\n" in the class. */
- #if 0
-     /* Remember whether \r or \n are in this class */
-     if (negate_class)
-       {
-       if ((classbits[1] & 0x24) != 0x24) cd->external_flags |= PCRE_HASCRORLF;
-       }
-     else
-       {
-       if ((classbits[1] & 0x24) != 0) cd->external_flags |= PCRE_HASCRORLF;
-       }
- #endif
      /* If class_charcount is 1, we saw precisely one character whose value is
      less than 256. As long as there were no characters >= 128 and there was no
      use of \p or \P, in other words, no use of any XCLASS features, we can
-Line 3475 
 we set the flag only if there is a liter
+Line 3790 
 we set the flag only if there is a liter
      can cause firstbyte to be set. Otherwise, there can be no first char if
      this item is first, whatever repeat count may follow. In the case of
      reqbyte, save the previous value for reinstating. */
  #ifdef SUPPORT_UTF8
      if (class_charcount == 1 && !class_utf8 &&
        (!utf8 || !negate_class || class_lastchar < 128))
-Line 3522 
 we set the flag only if there is a liter
+Line 3837 
 we set the flag only if there is a liter
      /* If there are characters with values > 255, we have to compile an
      extended class, with its own opcode, unless there was a negated special
-     such as \S in the class, because in that case all characters > 255 are in
+     such as \S in the class, and PCRE_UCP is not set, because in that case all
-     the class, so any that were explicitly given as well can be ignored. If
+     characters > 255 are in the class, so any that were explicitly given as
-     (when there are explicit characters > 255 that must be listed) there are no
+     well can be ignored. If (when there are explicit characters > 255 that must
-     characters < 256, we can omit the bitmap in the actual compiled code. */
+     be listed) there are no characters < 256, we can omit the bitmap in the
+     actual compiled code. */
  #ifdef SUPPORT_UTF8
-     if (class_utf8 && !should_flip_negation)
+     if (class_utf8 && (!should_flip_negation || (options & PCRE_UCP) != 0))
        {
        *class_utf8data++ = XCL_END;    /* Marks the end of extra data */
        *code++ = OP_XCLASS;
-Line 3554 
 we set the flag only if there is a liter
+Line 3870 
 we set the flag only if there is a liter
        }
  #endif
-     /* If there are no characters > 255, set the opcode to OP_CLASS or
+     /* If there are no characters > 255, or they are all to be included or
-     OP_NCLASS, depending on whether the whole class was negated and whether
+     excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the
-     there were negative specials such as \S in the class. Then copy the 32-byte
+     whole class was negated and whether there were negative specials such as \S
-     map into the code vector, negating it if necessary. */
+     (non-UCP) in the class. Then copy the 32-byte map into the code vector,
+     negating it if necessary. */
      *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
      if (negate_class)
-Line 3749 
 we set the flag only if there is a liter
+Line 4066 
 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 3899 
 we set the flag only if there is a liter
+Line 4221 
 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 3927 
 we set the flag only if there is a liter
+Line 4254 
 we set the flag only if there is a liter
        {
        register int i;
        int ketoffset = 0;
-       int len = code - previous;
+       int len = (int)(code - previous);
        uschar *bralink = NULL;
        /* Repeating a DEFINE group is pointless */
-Line 3948 
 we set the flag only if there is a liter
+Line 4275 
 we set the flag only if there is a liter
          {
          register uschar *ket = previous;
          do ket += GET(ket, 1); while (*ket != OP_KET);
-         ketoffset = code - ket;
+         ketoffset = (int)(code - ket);
          }
        /* The case of a zero minimum is special because of the need to stick
-Line 4016 
 we set the flag only if there is a liter
+Line 4343 
 we set the flag only if there is a liter
            /* We chain together the bracket offset fields that have to be
            filled in later when the ends of the brackets are reached. */
-           offset = (bralink == NULL)? 0 : previous - bralink;
+           offset = (bralink == NULL)? 0 : (int)(previous - bralink);
            bralink = previous;
            PUTINC(previous, 0, offset);
            }
-Line 4037 
 we set the flag only if there is a liter
+Line 4364 
 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 4089 
 we set the flag only if there is a liter
+Line 4418 
 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 4122 
 we set the flag only if there is a liter
+Line 4452 
 we set the flag only if there is a liter
              {
              int offset;
              *code++ = OP_BRA;
-             offset = (bralink == NULL)? 0 : code - bralink;
+             offset = (bralink == NULL)? 0 : (int)(code - bralink);
              bralink = code;
              PUTINC(code, 0, offset);
              }
-Line 4143 
 we set the flag only if there is a liter
+Line 4473 
 we set the flag only if there is a liter
          while (bralink != NULL)
            {
            int oldlinkoffset;
-           int offset = code - bralink + 1;
+           int offset = (int)(code - bralink + 1);
            uschar *bra = code - offset;
            oldlinkoffset = GET(bra, 1);
            bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
-Line 4174 
 we set the flag only if there is a liter
+Line 4504 
 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 4217 
 we set the flag only if there is a liter
+Line 4547 
 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);
-       len = code - tempcode;
+       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 = (int)(code - tempcode);
        if (len > 0) switch (*tempcode)
          {
          case OP_STAR:  *tempcode = OP_POSSTAR; break;
-Line 4240 
 we set the flag only if there is a liter
+Line 4579 
 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 4276 
 we set the flag only if there is a liter
+Line 4620 
 we set the flag only if there is a liter
      /* First deal with various "verbs" that can be introduced by '*'. */
-     if (*(++ptr) == CHAR_ASTERISK && (cd->ctypes[ptr[1]] & ctype_letter) != 0)
+     if (*(++ptr) == CHAR_ASTERISK &&
+          ((cd->ctypes[ptr[1]] & ctype_letter) != 0 || ptr[1] == ':'))
        {
        int i, namelen;
+       int arglen = 0;
        const char *vn = verbnames;
-       const uschar *name = ++ptr;
+       const uschar *name = ptr + 1;
+       const uschar *arg = NULL;
        previous = NULL;
        while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};
+       namelen = (int)(ptr - name);
        if (*ptr == CHAR_COLON)
          {
-         *errorcodeptr = ERR59;   /* Not supported */
+         arg = ++ptr;
-         goto FAILED;
+         while ((cd->ctypes[*ptr] & (ctype_letter|ctype_digit)) != 0
+           || *ptr == '_') ptr++;
+         arglen = ptr - arg;
          }
        if (*ptr != CHAR_RIGHT_PARENTHESIS)
          {
          *errorcodeptr = ERR60;
          goto FAILED;
          }
-       namelen = ptr - name;
+       /* Scan the table of verb names */
        for (i = 0; i < verbcount; i++)
          {
          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;
-           break;
+           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);
+               }
+             }
+           /* Handle the cases with/without an argument */
+           if (arglen == 0)
+             {
+             if (verbs[i].op < 0)   /* Argument is mandatory */
+               {
+               *errorcodeptr = ERR66;
+               goto FAILED;
+               }
+             *code++ = verbs[i].op;
+             }
+           else
+             {
+             if (verbs[i].op_arg < 0)   /* Argument is forbidden */
+               {
+               *errorcodeptr = ERR59;
+               goto FAILED;
+               }
+             *code++ = verbs[i].op_arg;
+             *code++ = arglen;
+             memcpy(code, arg, arglen);
+             code += arglen;
+             *code++ = 0;
+             }
+           break;  /* Found verb, exit loop */
            }
          vn += verbs[i].len + 1;
          }
-       if (i < verbcount) continue;
-       *errorcodeptr = ERR60;
+       if (i < verbcount) continue;    /* Successfully handled a verb */
+       *errorcodeptr = ERR60;          /* Verb not recognized */
        goto FAILED;
        }
-Line 4425 
 we set the flag only if there is a liter
+Line 4818 
 we set the flag only if there is a liter
                recno * 10 + *ptr - CHAR_0 : -1;
            ptr++;
            }
-         namelen = ptr - name;
+         namelen = (int)(ptr - name);
          if ((terminator > 0 && *ptr++ != terminator) ||
              *ptr++ != CHAR_RIGHT_PARENTHESIS)
-Line 4462 
 we set the flag only if there is a liter
+Line 4855 
 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 4477 
 we set the flag only if there is a liter
+Line 4873 
 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 4616 
 we set the flag only if there is a liter
+Line 5014 
 we set the flag only if there is a liter
              goto FAILED;
              }
            *code++ = n;
-           PUT(code, 0, ptr - cd->start_pattern + 1);  /* Pattern offset */
+           PUT(code, 0, (int)(ptr - cd->start_pattern + 1)); /* Pattern offset */
-           PUT(code, LINK_SIZE, 0);                    /* Default length */
+           PUT(code, LINK_SIZE, 0);                          /* Default length */
            code += 2 * LINK_SIZE;
            }
          previous = NULL;
-Line 4650 
 we set the flag only if there is a liter
+Line 5048 
 we set the flag only if there is a liter
            name = ++ptr;
            while ((cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
-           namelen = ptr - name;
+           namelen = (int)(ptr - name);
            /* In the pre-compile phase, just do a syntax check. */
-Line 4677 
 we set the flag only if there is a liter
+Line 5075 
 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 4689 
 we set the flag only if there is a liter
+Line 5100 
 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;
-Line 4734 
 we set the flag only if there is a liter
+Line 5178 
 we set the flag only if there is a liter
          NAMED_REF_OR_RECURSE:
          name = ++ptr;
          while ((cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
-         namelen = ptr - name;
+         namelen = (int)(ptr - name);
          /* In the pre-compile phase, do a syntax check and set a dummy
          reference number. */
-Line 4780 
 we set the flag only if there is a liter
+Line 5224 
 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 4884 
 we set the flag only if there is a liter
+Line 5328 
 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);
+               PUTINC(cd->hwm, 0, (int)(code + 2 + LINK_SIZE - cd->start_code));
                }
              /* If not a forward reference, and the subpattern is still open,
-Line 4905 
 we set the flag only if there is a liter
+Line 5355 
 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 4921 
 we set the flag only if there is a liter
+Line 5371 
 we set the flag only if there is a liter
            code += 1 + LINK_SIZE;
            *code = OP_RECURSE;
-           PUT(code, 1, called - cd->start_code);
+           PUT(code, 1, (int)(called - cd->start_code));
            code += 1 + LINK_SIZE;
            *code = OP_KET;
-Line 5000 
 we set the flag only if there is a liter
+Line 5450 
 we set the flag only if there is a liter
              {
              cd->external_options = newoptions;
              }
-          else
+           else
              {
              if ((options & PCRE_IMS) != (newoptions & PCRE_IMS))
                {
-Line 5032 
 we set the flag only if there is a liter
+Line 5482 
 we set the flag only if there is a liter
          }     /* End of switch for character following (? */
        }       /* End of (? handling */
-     /* Opening parenthesis not followed by '?'. If PCRE_NO_AUTO_CAPTURE is set,
+     /* Opening parenthesis not followed by '*' or '?'. If PCRE_NO_AUTO_CAPTURE
-     all unadorned brackets become non-capturing and behave like (?:...)
+     is set, all unadorned brackets become non-capturing and behave like (?:...)
      brackets. */
      else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)
-Line 5225 
 we set the flag only if there is a liter
+Line 5675 
 we set the flag only if there is a liter
      /* ===================================================================*/
      /* Handle metasequences introduced by \. For ones like \d, the ESC_ values
-     are arranged to be the negation of the corresponding OP_values. For the
+     are arranged to be the negation of the corresponding OP_values in the
-     back references, the values are ESC_REF plus the reference number. Only
+     default case when PCRE_UCP is not set. For the back references, the values
-     back references and those types that consume a character may be repeated.
+     are ESC_REF plus the reference number. Only back references and those types
-     We can test for values between ESC_b and ESC_Z for the latter; this may
+     that consume a character may be repeated. We can test for values between
-     have to change if any new ones are ever created. */
+     ESC_b and ESC_Z for the latter; this may have to change if any new ones are
+     ever created. */
      case CHAR_BACKSLASH:
      tempptr = ptr;
-Line 5337 
 we set the flag only if there is a liter
+Line 5788 
 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 5346 
 we set the flag only if there is a liter
+Line 5798 
 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 5375 
 we set the flag only if there is a liter
+Line 5840 
 we set the flag only if there is a liter
  #endif
        /* For the rest (including \X when Unicode properties are supported), we
-       can obtain the OP value by negating the escape value. */
+       can obtain the OP value by negating the escape value in the default
+       situation when PCRE_UCP is not set. When it *is* set, we substitute
+       Unicode property tests. */
        else
          {
-         previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;
+ #ifdef SUPPORT_UCP
-         *code++ = -c;
+         if (-c >= ESC_DU && -c <= ESC_wu)
+           {
+           nestptr = ptr + 1;                   /* Where to resume */
+           ptr = substitutes[-c - ESC_DU] - 1;  /* Just before substitute */
+           }
+         else
+ #endif
+           {
+           previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;
+           *code++ = -c;
+           }
          }
        continue;
        }
-Line 5528 
 uschar *code = *codeptr;
+Line 6005 
 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 5554 
 the code that abstracts option settings
+Line 6034 
 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 5598 
 for (;;)
+Line 6091 
 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 5648 
 for (;;)
+Line 6150 
 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 5679 
 for (;;)
+Line 6189 
 for (;;)
      {
      if (lengthptr == NULL)
        {
-       int branch_length = code - last_branch;
+       int branch_length = (int)(code - last_branch);
        do
          {
          int prev_length = GET(last_branch, 1);
-Line 5693 
 for (;;)
+Line 6203 
 for (;;)
      /* Fill in the ket */
      *code = OP_KET;
-     PUT(code, 1, code - start_bracket);
+     PUT(code, 1, (int)(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, (int)(code - start_bracket));
+         *code = OP_KET;
+         PUT(code, 1, (int)(code - start_bracket));
+         code += 1 + LINK_SIZE;
+         length += 2 + 2*LINK_SIZE;
+         }
+       cd->open_caps = cd->open_caps->next;
+       }
+     /* Reset options if needed. */
      if ((options & PCRE_IMS) != oldims && *ptr == CHAR_RIGHT_PARENTHESIS)
        {
-Line 5744 
 for (;;)
+Line 6275 
 for (;;)
    else
      {
      *code = OP_ALT;
-     PUT(code, 1, code - last_branch);
+     PUT(code, 1, (int)(code - last_branch));
-     bc.current = last_branch = code;
+     bc.current_branch = last_branch = code;
      code += 1 + LINK_SIZE;
      }
-Line 5892 
 do {
+Line 6423 
 do {
       switch (*scode)
         {
         case OP_CREF:
+        case OP_NCREF:
         case OP_RREF:
+        case OP_NRREF:
         case OP_DEF:
         return FALSE;
-Line 6061 
 int length = 1;  /* For final END opcode
+Line 6594 
 int length = 1;  /* For final END opcode
  int firstbyte, reqbyte, newline;
  int errorcode = 0;
  int skipatstart = 0;
- #ifdef SUPPORT_UTF8
  BOOL utf8;
- #endif
  size_t size;
  uschar *code;
  const uschar *codestart;
-Line 6106 
 if (erroroffset == NULL)
+Line 6637 
 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_COMPILE_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 6138 
 cd->fcc = tables + fcc_offset;
+Line 6645 
 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. */
-Line 6147 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 6662 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
    int newnl = 0;
    int newbsr = 0;
+   if (strncmp((char *)(ptr+skipatstart+2), STRING_UTF8_RIGHTPAR, 5) == 0)
+     { skipatstart += 7; options |= PCRE_UTF8; continue; }
+   else if (strncmp((char *)(ptr+skipatstart+2), STRING_UCP_RIGHTPAR, 4) == 0)
+     { skipatstart += 6; options |= PCRE_UCP; 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), STRING_LF_RIGHTPAR, 3)  == 0)
-Line 6169 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 6689 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
      options = (options & ~(PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) | newbsr;
    else break;
    }
+ utf8 = (options & PCRE_UTF8) != 0;
+ /* 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
+ /* Can't support UCP unless PCRE has been compiled to include the code. */
+ #ifndef SUPPORT_UCP
+ if ((options & PCRE_UCP) != 0)
+   {
+   errorcode = ERR67;
+   goto PCRE_EARLY_ERROR_RETURN;
+   }
+ #endif
  /* Check validity of \R options. */
-Line 6252 
 cd->end_pattern = (const uschar *)(patte
+Line 6801 
 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 6297 
 regex compiled on a system with 4-byte p
+Line 6847 
 regex compiled on a system with 4-byte p
  pointers. */
  re->magic_number = MAGIC_NUMBER;
- re->size = size;
+ re->size = (int)size;
  re->options = cd->external_options;
  re->flags = cd->external_flags;
  re->dummy1 = 0;
-Line 6326 
 cd->start_code = codestart;
+Line 6876 
 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 6351 
 if debugging, leave the test till after
+Line 6903 
 if debugging, leave the test till after
  *code++ = OP_END;
- #ifndef DEBUG
+ #ifndef PCRE_DEBUG
  if (code - codestart > length) errorcode = ERR23;
  #endif
-Line 6364 
 while (errorcode == 0 && cd->hwm > cwork
+Line 6916 
 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);
+     else PUT(((uschar *)codestart), offset, (int)(groupptr - codestart));
    }
  /* Give an error if there's back reference to a non-existent capturing
-Line 6374 
 subpattern. */
+Line 6926 
 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)
    {
    (pcre_free)(re);
    PCRE_EARLY_ERROR_RETURN:
-   *erroroffset = ptr - (const uschar *)pattern;
+   *erroroffset = (int)(ptr - (const uschar *)pattern);
    PCRE_EARLY_ERROR_RETURN2:
    *errorptr = find_error_text(errorcode);
    if (errorcodeptr != NULL) *errorcodeptr = errorcode;
-Line 6434 
 if (reqbyte >= 0 &&
+Line 7027 
 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 6472 
 if (code - codestart > length)
+Line 7064 
 if (code - codestart > length)
    if (errorcodeptr != NULL) *errorcodeptr = ERR23;
    return NULL;
    }
- #endif   /* DEBUG */
+ #endif   /* PCRE_DEBUG */
  return (pcre *)re;
  }

 Legend:



Removed from v.392
 


changed lines


 
Added in v.530
 Legend:



Removed from v.392
 


changed lines


 
Added in v.530
-Removed from v.392
+Added in v.530

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12