/[pcre]/code/branches/pcre16/pcre_compile.c

Diff of /code/branches/pcre16/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 483 by ph10,
Mon Jan  4 16:19:17 2010 UTC
+revision 602 by ph10,
Wed May 25 08:29:03 2011 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2010 University of Cambridge
+            Copyright (c) 1997-2011 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 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 119 
 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 166 
 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 183 
 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 197 
 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 251 
 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 263 
 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 310 
 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 336 
 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"
-Line 344 
 static const char error_texts[] =
+Line 405 
 static const char error_texts[] =
    "digit expected after (?+\0"
    "] is an invalid data character in JavaScript compatibility mode\0"
    /* 65 */
-   "different names for subpatterns of the same number are not allowed";
+   "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"
+   "\\c must be followed by an ASCII character\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 503 
 static const char *
+Line 567 
 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 574 
 else
+Line 642 
 else
      case CHAR_l:
      case CHAR_L:
-     case CHAR_N:
      case CHAR_u:
      case CHAR_U:
      *errorcodeptr = ERR37;
-Line 775 
 else
+Line 842 
 else
      break;
      /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.
-     This coding is ASCII-specific, but then the whole concept of \cx is
+     An error is given if the byte following \c is not an ASCII character. This
+     coding is ASCII-specific, but then the whole concept of \cx is
      ASCII-specific. (However, an EBCDIC equivalent has now been added.) */
      case CHAR_c:
-Line 785 
 else
+Line 853 
 else
        *errorcodeptr = ERR2;
        break;
        }
+ #ifndef EBCDIC    /* ASCII/UTF-8 coding */
- #ifndef EBCDIC  /* ASCII/UTF-8 coding */
+     if (c > 127)  /* Excludes all non-ASCII in either mode */
+       {
+       *errorcodeptr = ERR68;
+       break;
+       }
      if (c >= CHAR_a && c <= CHAR_z) c -= 32;
      c ^= 0x40;
- #else           /* EBCDIC coding */
+ #else             /* EBCDIC coding */
      if (c >= CHAR_a && c <= CHAR_z) c += 64;
      c ^= 0xC0;
  #endif
-Line 812 
 else
+Line 884 
 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 1020 
 top-level call starts at the beginning o
+Line 1105 
 top-level call starts at the beginning o
  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. We know that if (?P< is
+ returns when it reaches a given numbered subpattern. Recursion is used to keep
- encountered, the name will be terminated by '>' because that is checked in the
+ track of subpatterns that reset the capturing group numbers - the (?| feature.
- first pass. Recursion is used to keep track of subpatterns that reset the
- capturing group numbers - the (?| feature.
+ This function was originally called only from the second pass, in which we know
+ that if (?< or (?' or (?P< is encountered, the name will be correctly
+ terminated because that is checked in the first pass. There is now one call to
+ this function in the first pass, to check for a recursive back reference by
+ name (so that we can make the whole group atomic). In this case, we need check
+ only up to the current position in the pattern, and that is still OK because
+ and previous occurrences will have been checked. To make this work, the test
+ for "end of pattern" is a check against cd->end_pattern in the main loop,
+ instead of looking for a binary zero. This means that the special first-pass
+ call can adjust cd->end_pattern temporarily. (Checks for binary zero while
+ processing items within the loop are OK, because afterwards the main loop will
+ terminate.)
  Arguments:
    ptrptr       address of the current character pointer (updated)
-Line 1031 
 Arguments:
+Line 1127 
 Arguments:
    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
+   utf8         TRUE if we are in UTF-8 mode
    count        pointer to the current capturing subpattern number (updated)
  Returns:       the number of the named subpattern, or -1 if not found
-Line 1038 
 Returns:       the number of the named s
+Line 1135 
 Returns:       the number of the named s
  static int
  find_parens_sub(uschar **ptrptr, compile_data *cd, const uschar *name, int lorn,
-   BOOL xmode, int *count)
+   BOOL xmode, BOOL utf8, int *count)
  {
  uschar *ptr = *ptrptr;
  int start_count = *count;
-Line 1050 
 dealing with. The very first call may no
+Line 1147 
 dealing with. The very first call may no
  if (ptr[0] == CHAR_LEFT_PARENTHESIS)
    {
-   if (ptr[1] == CHAR_QUESTION_MARK &&
+   /* Handle specials such as (*SKIP) or (*UTF8) etc. */
-       ptr[2] == CHAR_VERTICAL_LINE)
+   if (ptr[1] == CHAR_ASTERISK) ptr += 2;
+   /* Handle a normal, unnamed capturing parenthesis. */
+   else if (ptr[1] != CHAR_QUESTION_MARK)
+     {
+     *count += 1;
+     if (name == NULL && *count == lorn) return *count;
+     ptr++;
+     }
+   /* All cases now have (? at the start. Remember when we are in a group
+   where the parenthesis numbers are duplicated. */
+   else if (ptr[2] == CHAR_VERTICAL_LINE)
      {
      ptr += 3;
      dup_parens = TRUE;
      }
-   /* Handle a normal, unnamed capturing parenthesis */
+   /* Handle comments; all characters are allowed until a ket is reached. */
-   else if (ptr[1] != CHAR_QUESTION_MARK && ptr[1] != CHAR_ASTERISK)
+   else if (ptr[2] == CHAR_NUMBER_SIGN)
      {
-     *count += 1;
+     for (ptr += 3; *ptr != 0; ptr++) if (*ptr == CHAR_RIGHT_PARENTHESIS) break;
-     if (name == NULL && *count == lorn) return *count;
+     goto FAIL_EXIT;
-     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. */
+   condition (there can't be any nested parens). */
    else if (ptr[2] == CHAR_LEFT_PARENTHESIS)
      {
-Line 1080 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
+Line 1191 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
        }
      }
-   /* We have either (? or (* and not a condition */
+   /* Start with (? but not a condition. */
    else
      {
-Line 1109 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
+Line 1220 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
    }
  /* Past any initial parenthesis handling, scan for parentheses or vertical
- bars. */
+ bars. Stop if we get to cd->end_pattern. Note that this is important for the
+ first-pass call when this value is temporarily adjusted to stop at the current
+ position. So DO NOT change this to a test for binary zero. */
- for (; *ptr != 0; ptr++)
+ for (; ptr < cd->end_pattern; ptr++)
    {
    /* Skip over backslashed characters and also entire \Q...\E */
-Line 1185 
 for (; *ptr != 0; ptr++)
+Line 1298 
 for (; *ptr != 0; ptr++)
    if (xmode && *ptr == CHAR_NUMBER_SIGN)
      {
-     while (*(++ptr) != 0 && *ptr != CHAR_NL) {};
+     ptr++;
+     while (*ptr != 0)
+       {
+       if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }
+       ptr++;
+ #ifdef SUPPORT_UTF8
+       if (utf8) while ((*ptr & 0xc0) == 0x80) ptr++;
+ #endif
+       }
      if (*ptr == 0) goto FAIL_EXIT;
      continue;
      }
-Line 1194 
 for (; *ptr != 0; ptr++)
+Line 1315 
 for (; *ptr != 0; ptr++)
    if (*ptr == CHAR_LEFT_PARENTHESIS)
      {
-     int rc = find_parens_sub(&ptr, cd, name, lorn, xmode, count);
+     int rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf8, count);
      if (rc > 0) return rc;
      if (*ptr == 0) goto FAIL_EXIT;
      }
-Line 1202 
 for (; *ptr != 0; ptr++)
+Line 1323 
 for (; *ptr != 0; ptr++)
    else if (*ptr == CHAR_RIGHT_PARENTHESIS)
      {
      if (dup_parens && *count < hwm_count) *count = hwm_count;
-     *ptrptr = ptr;
+     goto FAIL_EXIT;
-     return -1;
      }
    else if (*ptr == CHAR_VERTICAL_LINE && dup_parens)
-Line 1241 
 Arguments:
+Line 1361 
 Arguments:
    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
+   utf8         TRUE if we are in UTF-8 mode
  Returns:       the number of the found subpattern, or -1 if not found
  */
  static int
- find_parens(compile_data *cd, const uschar *name, int lorn, BOOL xmode)
+ find_parens(compile_data *cd, const uschar *name, int lorn, BOOL xmode,
+   BOOL utf8)
  {
  uschar *ptr = (uschar *)cd->start_pattern;
  int count = 0;
-Line 1259 
 matching closing parens. That is why we
+Line 1381 
 matching closing parens. That is why we
  for (;;)
    {
-   rc = find_parens_sub(&ptr, cd, name, lorn, xmode, &count);
+   rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf8, &count);
    if (rc > 0 || *ptr++ == 0) break;
    }
-Line 1275 
 return rc;
+Line 1397 
 return rc;
  /* This is called by several functions that scan a compiled expression looking
  for a fixed first character, or an anchoring op code etc. It skips over things
- that do not influence this. For some calls, a change of option is important.
+ that do not influence this. For some calls, it makes sense to skip negative
- For some calls, it makes sense to skip negative forward and all backward
+ forward and all backward assertions, and also the \b assertion; for others it
- assertions, and also the \b assertion; for others it does not.
+ does not.
  Arguments:
    code         pointer to the start of the group
-Line 1297 
 for (;;)
+Line 1419 
 for (;;)
    {
    switch ((int)*code)
      {
-     case OP_OPT:
-     if (optbit > 0 && ((int)code[1] & optbit) != (*options & optbit))
-       *options = (int)code[1];
-     code += 2;
-     break;
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
-Line 1439 
 for (;;)
+Line 1555 
 for (;;)
      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:
+     case OP_CIRCM:
      case OP_DOLL:
+     case OP_DOLLM:
      case OP_NOT_WORD_BOUNDARY:
      case OP_WORD_BOUNDARY:
      cc += _pcre_OP_lengths[*cc];
-Line 1455 
 for (;;)
+Line 1573 
 for (;;)
      /* Handle literal characters */
      case OP_CHAR:
-     case OP_CHARNC:
+     case OP_CHARI:
      case OP_NOT:
+     case OP_NOTI:
      branchlength++;
      cc += 2;
  #ifdef SUPPORT_UTF8
-Line 1602 
 for (;;)
+Line 1721 
 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 1626 
 for (;;)
+Line 1746 
 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:
+       code += code[1];
+       break;
+       case OP_THEN_ARG:
+       code += code[1+LINK_SIZE];
+       break;
        }
      /* Add in the fixed length from the table */
-Line 1640 
 for (;;)
+Line 1770 
 for (;;)
      if (utf8) switch(c)
        {
        case OP_CHAR:
-       case OP_CHARNC:
+       case OP_CHARI:
        case OP_EXACT:
+       case OP_EXACTI:
        case OP_UPTO:
+       case OP_UPTOI:
        case OP_MINUPTO:
+       case OP_MINUPTOI:
        case OP_POSUPTO:
+       case OP_POSUPTOI:
        case OP_STAR:
+       case OP_STARI:
        case OP_MINSTAR:
+       case OP_MINSTARI:
        case OP_POSSTAR:
+       case OP_POSSTARI:
        case OP_PLUS:
+       case OP_PLUSI:
        case OP_MINPLUS:
+       case OP_MINPLUSI:
        case OP_POSPLUS:
+       case OP_POSPLUSI:
        case OP_QUERY:
+       case OP_QUERYI:
        case OP_MINQUERY:
+       case OP_MINQUERYI:
        case OP_POSQUERY:
+       case OP_POSQUERYI:
        if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
        break;
        }
-Line 1697 
 for (;;)
+Line 1840 
 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 1721 
 for (;;)
+Line 1865 
 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:
+       code += code[1];
+       break;
+       case OP_THEN_ARG:
+       code += code[1+LINK_SIZE];
+       break;
        }
      /* Add in the fixed length from the table */
-Line 1735 
 for (;;)
+Line 1889 
 for (;;)
      if (utf8) switch(c)
        {
        case OP_CHAR:
-       case OP_CHARNC:
+       case OP_CHARI:
        case OP_EXACT:
+       case OP_EXACTI:
        case OP_UPTO:
+       case OP_UPTOI:
        case OP_MINUPTO:
+       case OP_MINUPTOI:
        case OP_POSUPTO:
+       case OP_POSUPTOI:
        case OP_STAR:
+       case OP_STARI:
        case OP_MINSTAR:
+       case OP_MINSTARI:
        case OP_POSSTAR:
+       case OP_POSSTARI:
        case OP_PLUS:
+       case OP_PLUSI:
        case OP_MINPLUS:
+       case OP_MINPLUSI:
        case OP_POSPLUS:
+       case OP_POSPLUSI:
        case OP_QUERY:
+       case OP_QUERYI:
        case OP_MINQUERY:
+       case OP_MINQUERYI:
        case OP_POSQUERY:
+       case OP_POSQUERYI:
        if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
        break;
        }
-Line 1777 
 Arguments:
+Line 1944 
 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 1813 
 for (code = first_significant_code(code
+Line 1982 
 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 1831 
 for (code = first_significant_code(code
+Line 2022 
 for (code = first_significant_code(code
        empty_branch = FALSE;
        do
          {
-         if (!empty_branch && could_be_empty_branch(code, endcode, utf8))
+         if (!empty_branch && could_be_empty_branch(code, endcode, utf8, cd))
            empty_branch = TRUE;
          code += GET(code, 1);
          }
-Line 1902 
 for (code = first_significant_code(code
+Line 2093 
 for (code = first_significant_code(code
      case OP_ALLANY:
      case OP_ANYBYTE:
      case OP_CHAR:
-     case OP_CHARNC:
+     case OP_CHARI:
      case OP_NOT:
+     case OP_NOTI:
      case OP_PLUS:
      case OP_MINPLUS:
      case OP_POSPLUS:
-Line 1951 
 for (code = first_significant_code(code
+Line 2143 
 for (code = first_significant_code(code
  #ifdef SUPPORT_UTF8
      case OP_STAR:
+     case OP_STARI:
      case OP_MINSTAR:
+     case OP_MINSTARI:
      case OP_POSSTAR:
+     case OP_POSSTARI:
      case OP_QUERY:
+     case OP_QUERYI:
      case OP_MINQUERY:
+     case OP_MINQUERYI:
      case OP_POSQUERY:
+     case OP_POSQUERYI:
      if (utf8 && code[1] >= 0xc0) code += _pcre_utf8_table4[code[1] & 0x3f];
      break;
      case OP_UPTO:
+     case OP_UPTOI:
      case OP_MINUPTO:
+     case OP_MINUPTOI:
      case OP_POSUPTO:
+     case OP_POSUPTOI:
      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:
+     code += code[1];
+     break;
+     case OP_THEN_ARG:
+     code += code[1+LINK_SIZE];
+     break;
+     /* None of the remaining opcodes are required to match a character. */
+     default:
+     break;
      }
    }
-Line 1987 
 Arguments:
+Line 2206 
 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_branch >= code)
    {
-   if (!could_be_empty_branch(bcptr->current_branch, endcode, utf8))
+   if (!could_be_empty_branch(bcptr->current_branch, endcode, utf8, cd))
      return FALSE;
    bcptr = bcptr->outer;
    }
-Line 2180 
 auto_callout(uschar *code, const uschar
+Line 2400 
 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 2206 
 Returns:             nothing
+Line 2426 
 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 2256 
 for (++c; c <= d; c++)
+Line 2476 
 for (++c; c <= d; c++)
  return TRUE;
  }
+ /*************************************************
+ *        Check a character and a property        *
+ *************************************************/
+ /* This function is called by check_auto_possessive() when a property item
+ is adjacent to a fixed character.
+ Arguments:
+   c            the character
+   ptype        the property type
+   pdata        the data for the type
+   negated      TRUE if it's a negated property (\P or \p{^)
+ Returns:       TRUE if auto-possessifying is OK
+ */
+ static BOOL
+ check_char_prop(int c, int ptype, int pdata, BOOL negated)
+ {
+ const ucd_record *prop = GET_UCD(c);
+ switch(ptype)
+   {
+   case PT_LAMP:
+   return (prop->chartype == ucp_Lu ||
+           prop->chartype == ucp_Ll ||
+           prop->chartype == ucp_Lt) == negated;
+   case PT_GC:
+   return (pdata == _pcre_ucp_gentype[prop->chartype]) == negated;
+   case PT_PC:
+   return (pdata == prop->chartype) == negated;
+   case PT_SC:
+   return (pdata == prop->script) == negated;
+   /* These are specials */
+   case PT_ALNUM:
+   return (_pcre_ucp_gentype[prop->chartype] == ucp_L ||
+           _pcre_ucp_gentype[prop->chartype] == ucp_N) == negated;
+   case PT_SPACE:    /* Perl space */
+   return (_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+           c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
+           == negated;
+   case PT_PXSPACE:  /* POSIX space */
+   return (_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+           c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
+           c == CHAR_FF || c == CHAR_CR)
+           == negated;
+   case PT_WORD:
+   return (_pcre_ucp_gentype[prop->chartype] == ucp_L ||
+           _pcre_ucp_gentype[prop->chartype] == ucp_N ||
+           c == CHAR_UNDERSCORE) == negated;
+   }
+ return FALSE;
+ }
  #endif  /* SUPPORT_UCP */
-Line 2269 
 whether the next thing could possibly ma
+Line 2552 
 whether the next thing could possibly ma
  sense to automatically possessify the repeated item.
  Arguments:
-   op_code       the repeated op code
+   previous      pointer to the repeated opcode
-   this          data for this item, depends on the opcode
    utf8          TRUE in UTF-8 mode
-   utf8_char     used for utf8 character bytes, NULL if not relevant
    ptr           next character in pattern
    options       options bits
    cd            contains pointers to tables etc.
-Line 2281 
 Returns:        TRUE if possessifying is
+Line 2562 
 Returns:        TRUE if possessifying is
  */
  static BOOL
- check_auto_possessive(int op_code, int item, BOOL utf8, uschar *utf8_char,
+ check_auto_possessive(const uschar *previous, BOOL utf8, const uschar *ptr,
-   const uschar *ptr, int options, compile_data *cd)
+   int options, compile_data *cd)
  {
- int next;
+ int c, next;
+ int op_code = *previous++;
  /* Skip whitespace and comments in extended mode */
-Line 2295 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2577 
 if ((options & PCRE_EXTENDED) != 0)
      while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
      if (*ptr == CHAR_NUMBER_SIGN)
        {
-       while (*(++ptr) != 0)
+       ptr++;
+       while (*ptr != 0)
+         {
          if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
+         ptr++;
+ #ifdef SUPPORT_UTF8
+         if (utf8) while ((*ptr & 0xc0) == 0x80) ptr++;
+ #endif
+         }
        }
      else break;
      }
-Line 2332 
 if ((options & PCRE_EXTENDED) != 0)
+Line 2621 
 if ((options & PCRE_EXTENDED) != 0)
      while ((cd->ctypes[*ptr] & ctype_space) != 0) ptr++;
      if (*ptr == CHAR_NUMBER_SIGN)
        {
-       while (*(++ptr) != 0)
+       ptr++;
+       while (*ptr != 0)
+         {
          if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
+         ptr++;
+ #ifdef SUPPORT_UTF8
+         if (utf8) while ((*ptr & 0xc0) == 0x80) ptr++;
+ #endif
+         }
        }
      else break;
      }
-Line 2345 
 if (*ptr == CHAR_ASTERISK || *ptr == CHA
+Line 2641 
 if (*ptr == CHAR_ASTERISK || *ptr == CHA
    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
+ /* Now compare the next item with the previous opcode. First, handle cases when
- positive single character match, "item" either contains the character or, if
+ the next item is a character. */
- "item" is greater than 127 in utf8 mode, the character's bytes are in
- utf8_char. */
- /* Handle cases when the next item is a character. */
  if (next >= 0) switch(op_code)
    {
    case OP_CHAR:
  #ifdef SUPPORT_UTF8
-   if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
+   GETCHARTEST(c, previous);
  #else
-   (void)(utf8_char);  /* Keep compiler happy by referencing function argument */
+   c = *previous;
  #endif
-   return item != next;
+   return c != next;
-   /* For CHARNC (caseless character) we must check the other case. If we have
+   /* For CHARI (caseless character) we must check the other case. If we have
    Unicode property support, we can use it to test the other case of
    high-valued characters. */
-   case OP_CHARNC:
+   case OP_CHARI:
  #ifdef SUPPORT_UTF8
-   if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
+   GETCHARTEST(c, previous);
+ #else
+   c = *previous;
  #endif
-   if (item == next) return FALSE;
+   if (c == next) return FALSE;
  #ifdef SUPPORT_UTF8
    if (utf8)
      {
-Line 2382 
 if (next >= 0) switch(op_code)
+Line 2675 
 if (next >= 0) switch(op_code)
  #else
      othercase = NOTACHAR;
  #endif
-     return (unsigned int)item != othercase;
+     return (unsigned int)c != othercase;
      }
    else
  #endif  /* SUPPORT_UTF8 */
-   return (item != cd->fcc[next]);  /* Non-UTF-8 mode */
+   return (c != cd->fcc[next]);  /* Non-UTF-8 mode */
-   /* For OP_NOT, "item" must be a single-byte character. */
+   /* For OP_NOT and OP_NOTI, the data is always a single-byte character. These
+   opcodes are not used for multi-byte characters, because they are coded using
+   an XCLASS instead. */
    case OP_NOT:
-   if (item == next) return TRUE;
+   return (c = *previous) == next;
-   if ((options & PCRE_CASELESS) == 0) return FALSE;
+   case OP_NOTI:
+   if ((c = *previous) == next) return TRUE;
  #ifdef SUPPORT_UTF8
    if (utf8)
      {
-Line 2403 
 if (next >= 0) switch(op_code)
+Line 2700 
 if (next >= 0) switch(op_code)
  #else
      othercase = NOTACHAR;
  #endif
-     return (unsigned int)item == othercase;
+     return (unsigned int)c == othercase;
      }
    else
  #endif  /* SUPPORT_UTF8 */
-   return (item == cd->fcc[next]);  /* Non-UTF-8 mode */
+   return (c == 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 2450 
 if (next >= 0) switch(op_code)
+Line 2750 
 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 2466 
 if (next >= 0) switch(op_code)
+Line 2767 
 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;
      }
+ #ifdef SUPPORT_UCP
+   case OP_PROP:
+   return check_char_prop(next, previous[0], previous[1], FALSE);
+   case OP_NOTPROP:
+   return check_char_prop(next, previous[0], previous[1], TRUE);
+ #endif
    default:
    return FALSE;
    }
- /* 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. Similarly, the opcodes OP_DIGIT etc. are
+ replaced by OP_PROP codes when PCRE_UCP is set. */
  switch(op_code)
    {
    case OP_CHAR:
-   case OP_CHARNC:
+   case OP_CHARI:
  #ifdef SUPPORT_UTF8
-   if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
+   GETCHARTEST(c, previous);
+ #else
+   c = *previous;
  #endif
    switch(-next)
      {
      case ESC_d:
-     return item > 127 || (cd->ctypes[item] & ctype_digit) == 0;
+     return c > 127 || (cd->ctypes[c] & ctype_digit) == 0;
      case ESC_D:
-     return item <= 127 && (cd->ctypes[item] & ctype_digit) != 0;
+     return c <= 127 && (cd->ctypes[c] & ctype_digit) != 0;
      case ESC_s:
-     return item > 127 || (cd->ctypes[item] & ctype_space) == 0;
+     return c > 127 || (cd->ctypes[c] & ctype_space) == 0;
      case ESC_S:
-     return item <= 127 && (cd->ctypes[item] & ctype_space) != 0;
+     return c <= 127 && (cd->ctypes[c] & ctype_space) != 0;
      case ESC_w:
-     return item > 127 || (cd->ctypes[item] & ctype_word) == 0;
+     return c > 127 || (cd->ctypes[c] & ctype_word) == 0;
      case ESC_W:
-     return item <= 127 && (cd->ctypes[item] & ctype_word) != 0;
+     return c <= 127 && (cd->ctypes[c] & ctype_word) != 0;
      case ESC_h:
      case ESC_H:
-     switch(item)
+     switch(c)
        {
        case 0x09:
        case 0x20:
-Line 2535 
 switch(op_code)
+Line 2850 
 switch(op_code)
      case ESC_v:
      case ESC_V:
-     switch(item)
+     switch(c)
        {
        case 0x0a:
        case 0x0b:
-Line 2549 
 switch(op_code)
+Line 2864 
 switch(op_code)
        return -next == ESC_v;
        }
+     /* When PCRE_UCP is set, these values get generated for \d etc. Find
+     their substitutions and process them. The result will always be either
+     -ESC_p or -ESC_P. Then fall through to process those values. */
+ #ifdef SUPPORT_UCP
+     case ESC_du:
+     case ESC_DU:
+     case ESC_wu:
+     case ESC_WU:
+     case ESC_su:
+     case ESC_SU:
+       {
+       int temperrorcode = 0;
+       ptr = substitutes[-next - ESC_DU];
+       next = check_escape(&ptr, &temperrorcode, 0, options, FALSE);
+       if (temperrorcode != 0) return FALSE;
+       ptr++;    /* For compatibility */
+       }
+     /* Fall through */
+     case ESC_p:
+     case ESC_P:
+       {
+       int ptype, pdata, errorcodeptr;
+       BOOL negated;
+       ptr--;      /* Make ptr point at the p or P */
+       ptype = get_ucp(&ptr, &negated, &pdata, &errorcodeptr);
+       if (ptype < 0) return FALSE;
+       ptr++;      /* Point past the final curly ket */
+       /* If the property item is optional, we have to give up. (When generated
+       from \d etc by PCRE_UCP, this test will have been applied much earlier,
+       to the original \d etc. At this point, ptr will point to a zero byte. */
+       if (*ptr == CHAR_ASTERISK || *ptr == CHAR_QUESTION_MARK ||
+         strncmp((char *)ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
+           return FALSE;
+       /* Do the property check. */
+       return check_char_prop(c, ptype, pdata, (next == -ESC_P) != negated);
+       }
+ #endif
      default:
      return FALSE;
      }
+   /* In principle, support for Unicode properties should be integrated here as
+   well. It means re-organizing the above code so as to get hold of the property
+   values before switching on the op-code. However, I wonder how many patterns
+   combine ASCII \d etc with Unicode properties? (Note that if PCRE_UCP is set,
+   these op-codes are never generated.) */
    case OP_DIGIT:
    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 2644 
 BOOL inescq = FALSE;
+Line 3013 
 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 2714 
 for (;; ptr++)
+Line 3084 
 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. */
-Line 2722 
 for (;; ptr++)
+Line 3102 
 for (;; ptr++)
  #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 2744 
 for (;; ptr++)
+Line 3124 
 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 2771 
 for (;; ptr++)
+Line 3151 
 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 2826 
 for (;; ptr++)
+Line 3206 
 for (;; ptr++)
      if ((cd->ctypes[c] & ctype_space) != 0) continue;
      if (c == CHAR_NUMBER_SIGN)
        {
-       while (*(++ptr) != 0)
+       ptr++;
+       while (*ptr != 0)
          {
          if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }
+         ptr++;
+ #ifdef SUPPORT_UTF8
+         if (utf8) while ((*ptr & 0xc0) == 0x80) ptr++;
+ #endif
          }
        if (*ptr != 0) continue;
-Line 2862 
 for (;; ptr++)
+Line 3247 
 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 2873 
 for (;; ptr++)
+Line 3258 
 for (;; ptr++)
      the setting of any following char as a first character. */
      case CHAR_CIRCUMFLEX_ACCENT:
+     previous = NULL;
      if ((options & PCRE_MULTILINE) != 0)
        {
        if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
+       *code++ = OP_CIRCM;
        }
-     previous = NULL;
+     else *code++ = OP_CIRC;
-     *code++ = OP_CIRC;
      break;
      case CHAR_DOLLAR_SIGN:
      previous = NULL;
-     *code++ = OP_DOLL;
+     *code++ = ((options & PCRE_MULTILINE) != 0)? OP_DOLLM : OP_DOLL;
      break;
      /* There can never be a first char if '.' is first, whatever happens about
-Line 3067 
 for (;; ptr++)
+Line 3453 
 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 3081 
 for (;; ptr++)
+Line 3467 
 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 3128 
 for (;; ptr++)
+Line 3529 
 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 3157 
 for (;; ptr++)
+Line 3557 
 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 3179 
 for (;; ptr++)
+Line 3589 
 for (;; ptr++)
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
              continue;
+             /* Perl 5.004 onwards omits VT from \s, but we must preserve it
+             if it was previously set by something earlier in the character
+             class. */
              case ESC_s:
-             for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
+             classbits[0] |= cbits[cbit_space];
-             classbits[1] &= ~0x08;   /* Perl 5.004 onwards omits VT from \s */
+             classbits[1] |= cbits[cbit_space+1] & ~0x08;
+             for (c = 2; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
              continue;
              case ESC_S:
-Line 3190 
 for (;; ptr++)
+Line 3605 
 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 3227 
 for (;; ptr++)
+Line 3629 
 for (;; ptr++)
                }
  #endif
              continue;
-             }
-           if (-c == ESC_H)
+             case ESC_H:
-             {
              for (c = 0; c < 32; c++)
                {
                int x = 0xff;
-Line 3272 
 for (;; ptr++)
+Line 3672 
 for (;; ptr++)
                }
  #endif
              continue;
-             }
-           if (-c == ESC_v)
+             case ESC_v:
-             {
              SETBIT(classbits, 0x0a); /* LF */
              SETBIT(classbits, 0x0b); /* VT */
              SETBIT(classbits, 0x0c); /* FF */
-Line 3291 
 for (;; ptr++)
+Line 3689 
 for (;; ptr++)
                }
  #endif
              continue;
-             }
-           if (-c == ESC_V)
+             case ESC_V:
-             {
              for (c = 0; c < 32; c++)
                {
                int x = 0xff;
-Line 3324 
 for (;; ptr++)
+Line 3720 
 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 3425 
 for (;; ptr++)
+Line 3821 
 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 3598 
 for (;; ptr++)
+Line 3991 
 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 3634 
 we set the flag only if there is a liter
+Line 4015 
 we set the flag only if there is a liter
      In UTF-8 mode, we can optimize the negative case only if there were no
      characters >= 128 because OP_NOT and the related opcodes like OP_NOTSTAR
-     operate on single-bytes only. This is an historical hangover. Maybe one day
+     operate on single-bytes characters only. This is an historical hangover.
-     we can tidy these opcodes to handle multi-byte characters.
+     Maybe one day we can tidy these opcodes to handle multi-byte characters.
      The optimization throws away the bit map. We turn the item into a
--character OP_CHAR[NC] if it's positive, or OP_NOT if it's negative. Note
+-character OP_CHAR[I] if it's positive, or OP_NOT[I] if it's negative.
-     that OP_NOT does not support multibyte characters. In the positive case, it
+     Note that OP_NOT[I] does not support multibyte characters. In the positive
-     can cause firstbyte to be set. Otherwise, there can be no first char if
+     case, it can cause firstbyte to be set. Otherwise, there can be no first
-     this item is first, whatever repeat count may follow. In the case of
+     char if this item is first, whatever repeat count may follow. In the case
-     reqbyte, save the previous value for reinstating. */
+     of reqbyte, save the previous value for reinstating. */
  #ifdef SUPPORT_UTF8
      if (class_charcount == 1 && !class_utf8 &&
-Line 3653 
 we set the flag only if there is a liter
+Line 4034 
 we set the flag only if there is a liter
        {
        zeroreqbyte = reqbyte;
-       /* The OP_NOT opcode works on one-byte characters only. */
+       /* The OP_NOT[I] opcodes work on one-byte characters only. */
        if (negate_class)
          {
          if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
          zerofirstbyte = firstbyte;
-         *code++ = OP_NOT;
+         *code++ = ((options & PCRE_CASELESS) != 0)? OP_NOTI: OP_NOT;
          *code++ = class_lastchar;
          break;
          }
-Line 3690 
 we set the flag only if there is a liter
+Line 4071 
 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 3722 
 we set the flag only if there is a liter
+Line 4104 
 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 3815 
 we set the flag only if there is a liter
+Line 4198 
 we set the flag only if there is a liter
      the first thing in a branch because the x will have gone into firstbyte
      instead.  */
-     if (*previous == OP_CHAR || *previous == OP_CHARNC)
+     if (*previous == OP_CHAR || *previous == OP_CHARI)
        {
+       op_type = (*previous == OP_CHAR)? 0 : OP_STARI - OP_STAR;
        /* Deal with UTF-8 characters that take up more than one byte. It's
        easier to write this out separately than try to macrify it. Use c to
        hold the length of the character in bytes, plus 0x80 to flag that it's a
-Line 3849 
 we set the flag only if there is a liter
+Line 4234 
 we set the flag only if there is a liter
        if (!possessive_quantifier &&
            repeat_max < 0 &&
-           check_auto_possessive(*previous, c, utf8, utf8_char, ptr + 1,
+           check_auto_possessive(previous, utf8, ptr + 1, options, cd))
-             options, cd))
          {
          repeat_type = 0;    /* Force greedy */
          possessive_quantifier = TRUE;
-Line 3862 
 we set the flag only if there is a liter
+Line 4246 
 we set the flag only if there is a liter
      /* If previous was a single negated character ([^a] or similar), we use
      one of the special opcodes, replacing it. The code is shared with single-
      character repeats by setting opt_type to add a suitable offset into
-     repeat_type. We can also test for auto-possessification. OP_NOT is
+     repeat_type. We can also test for auto-possessification. OP_NOT and OP_NOTI
-     currently used only for single-byte chars. */
+     are currently used only for single-byte chars. */
-     else if (*previous == OP_NOT)
+     else if (*previous == OP_NOT || *previous == OP_NOTI)
        {
-       op_type = OP_NOTSTAR - OP_STAR;  /* Use "not" opcodes */
+       op_type = ((*previous == OP_NOT)? OP_NOTSTAR : OP_NOTSTARI) - OP_STAR;
        c = previous[1];
        if (!possessive_quantifier &&
            repeat_max < 0 &&
-           check_auto_possessive(OP_NOT, c, utf8, NULL, ptr + 1, options, cd))
+           check_auto_possessive(previous, utf8, ptr + 1, options, cd))
          {
          repeat_type = 0;    /* Force greedy */
          possessive_quantifier = TRUE;
-Line 3895 
 we set the flag only if there is a liter
+Line 4279 
 we set the flag only if there is a liter
        if (!possessive_quantifier &&
            repeat_max < 0 &&
-           check_auto_possessive(c, 0, utf8, NULL, ptr + 1, options, cd))
+           check_auto_possessive(previous, utf8, ptr + 1, options, cd))
          {
          repeat_type = 0;    /* Force greedy */
          possessive_quantifier = TRUE;
-Line 4064 
 we set the flag only if there is a liter
+Line 4448 
 we set the flag only if there is a liter
  #ifdef SUPPORT_UTF8
               *previous == OP_XCLASS ||
  #endif
-              *previous == OP_REF)
+              *previous == OP_REF ||
+              *previous == OP_REFI)
        {
        if (repeat_max == 0)
          {
-Line 4105 
 we set the flag only if there is a liter
+Line 4490 
 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 4118 
 we set the flag only if there is a liter
+Line 4503 
 we set the flag only if there is a liter
        /* If the maximum repeat count is unlimited, find the end of the bracket
        by scanning through from the start, and compute the offset back to it
-       from the current code pointer. There may be an OP_OPT setting following
+       from the current code pointer. */
-       the final KET, so we can't find the end just by going back from the code
-       pointer. */
        if (repeat_max == -1)
          {
          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 4194 
 we set the flag only if there is a liter
+Line 4577 
 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 4222 
 we set the flag only if there is a liter
+Line 4605 
 we set the flag only if there is a liter
              {
              int delta = (repeat_min - 1)*length_prevgroup;
              if ((INT64_OR_DOUBLE)(repeat_min - 1)*
                    (INT64_OR_DOUBLE)length_prevgroup >
                      (INT64_OR_DOUBLE)INT_MAX ||
                  OFLOW_MAX - *lengthptr < delta)
                {
-Line 4269 
 we set the flag only if there is a liter
+Line 4652 
 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. The INT64_OR_DOUBLE type is
          a 64-bit integer type when available, otherwise double. */
          if (lengthptr != NULL && repeat_max > 0)
-Line 4303 
 we set the flag only if there is a liter
+Line 4686 
 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 4324 
 we set the flag only if there is a liter
+Line 4707 
 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 4355 
 we set the flag only if there is a liter
+Line 4738 
 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 4412 
 we set the flag only if there is a liter
+Line 4795 
 we set the flag only if there is a liter
  #endif
          }
-       len = code - tempcode;
+       len = (int)(code - tempcode);
        if (len > 0) switch (*tempcode)
          {
          case OP_STAR:  *tempcode = OP_POSSTAR; break;
-Line 4420 
 we set the flag only if there is a liter
+Line 4803 
 we set the flag only if there is a liter
          case OP_QUERY: *tempcode = OP_POSQUERY; break;
          case OP_UPTO:  *tempcode = OP_POSUPTO; break;
-         case OP_TYPESTAR:  *tempcode = OP_TYPEPOSSTAR; break;
+         case OP_STARI:  *tempcode = OP_POSSTARI; break;
-         case OP_TYPEPLUS:  *tempcode = OP_TYPEPOSPLUS; break;
+         case OP_PLUSI:  *tempcode = OP_POSPLUSI; break;
-         case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;
+         case OP_QUERYI: *tempcode = OP_POSQUERYI; break;
-         case OP_TYPEUPTO:  *tempcode = OP_TYPEPOSUPTO; break;
+         case OP_UPTOI:  *tempcode = OP_POSUPTOI; break;
          case OP_NOTSTAR:  *tempcode = OP_NOTPOSSTAR; break;
          case OP_NOTPLUS:  *tempcode = OP_NOTPOSPLUS; break;
          case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;
          case OP_NOTUPTO:  *tempcode = OP_NOTPOSUPTO; break;
+         case OP_NOTSTARI:  *tempcode = OP_NOTPOSSTARI; break;
+         case OP_NOTPLUSI:  *tempcode = OP_NOTPOSPLUSI; break;
+         case OP_NOTQUERYI: *tempcode = OP_NOTPOSQUERYI; break;
+         case OP_NOTUPTOI:  *tempcode = OP_NOTPOSUPTOI; break;
+         case OP_TYPESTAR:  *tempcode = OP_TYPEPOSSTAR; break;
+         case OP_TYPEPLUS:  *tempcode = OP_TYPEPOSPLUS; break;
+         case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;
+         case OP_TYPEUPTO:  *tempcode = OP_TYPEPOSUPTO; 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 4466 
 we set the flag only if there is a liter
+Line 4864 
 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 = (int)(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 &&
-Line 4501 
 we set the flag only if there is a liter
+Line 4909 
 we set the flag only if there is a liter
                PUT2INC(code, 0, oc->number);
                }
              }
-           *code++ = verbs[i].op;
-           break;
+           /* 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;
+             if (*code++ == OP_THEN)
+               {
+               PUT(code, 0, code - bcptr->current_branch - 1);
+               code += LINK_SIZE;
+               }
+             }
+           else
+             {
+             if (verbs[i].op_arg < 0)   /* Argument is forbidden */
+               {
+               *errorcodeptr = ERR59;
+               goto FAILED;
+               }
+             *code = verbs[i].op_arg;
+             if (*code++ == OP_THEN_ARG)
+               {
+               PUT(code, 0, code - bcptr->current_branch - 1);
+               code += LINK_SIZE;
+               }
+             *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 4626 
 we set the flag only if there is a liter
+Line 5072 
 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 4687 
 we set the flag only if there is a liter
+Line 5133 
 we set the flag only if there is a liter
          /* Search the pattern for a forward reference */
          else if ((i = find_parens(cd, name, namelen,
-                         (options & PCRE_EXTENDED) != 0)) > 0)
+                         (options & PCRE_EXTENDED) != 0, utf8)) > 0)
            {
            PUT2(code, 2+LINK_SIZE, i);
            code[1+LINK_SIZE]++;
-Line 4822 
 we set the flag only if there is a liter
+Line 5268 
 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 4856 
 we set the flag only if there is a liter
+Line 5302 
 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 4986 
 we set the flag only if there is a liter
+Line 5432 
 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
+         /* In the pre-compile phase, do a syntax check. We used to just set
-         reference number. */
+         a dummy reference number, because it was not used in the first pass.
+         However, with the change of recursive back references to be atomic,
+         we have to look for the number so that this state can be identified, as
+         otherwise the incorrect length is computed. If it's not a backwards
+         reference, the dummy number will do. */
          if (lengthptr != NULL)
            {
+           const uschar *temp;
            if (namelen == 0)
              {
              *errorcodeptr = ERR62;
-Line 5008 
 we set the flag only if there is a liter
+Line 5460 
 we set the flag only if there is a liter
              *errorcodeptr = ERR48;
              goto FAILED;
              }
-           recno = 0;
+           /* The name table does not exist in the first pass, so we cannot
+           do a simple search as in the code below. Instead, we have to scan the
+           pattern to find the number. It is important that we scan it only as
+           far as we have got because the syntax of named subpatterns has not
+           been checked for the rest of the pattern, and find_parens() assumes
+           correct syntax. In any case, it's a waste of resources to scan
+           further. We stop the scan at the current point by temporarily
+           adjusting the value of cd->endpattern. */
+           temp = cd->end_pattern;
+           cd->end_pattern = ptr;
+           recno = find_parens(cd, name, namelen,
+             (options & PCRE_EXTENDED) != 0, utf8);
+           cd->end_pattern = temp;
+           if (recno < 0) recno = 0;    /* Forward ref; set dummy number */
            }
          /* In the real compile, seek the name in the table. We check the name
-Line 5033 
 we set the flag only if there is a liter
+Line 5500 
 we set the flag only if there is a liter
              }
            else if ((recno =                /* Forward back reference */
                      find_parens(cd, name, namelen,
-                       (options & PCRE_EXTENDED) != 0)) <= 0)
+                       (options & PCRE_EXTENDED) != 0, utf8)) <= 0)
              {
              *errorcodeptr = ERR15;
              goto FAILED;
-Line 5144 
 we set the flag only if there is a liter
+Line 5611 
 we set the flag only if there is a liter
              if (called == NULL)
                {
                if (find_parens(cd, NULL, recno,
-                     (options & PCRE_EXTENDED) != 0) < 0)
+                     (options & PCRE_EXTENDED) != 0, utf8) < 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 5158 
 we set the flag only if there is a liter
+Line 5630 
 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 5174 
 we set the flag only if there is a liter
+Line 5646 
 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 5255 
 we set the flag only if there is a liter
+Line 5727 
 we set the flag only if there is a liter
              }
            else
              {
-             if ((options & PCRE_IMS) != (newoptions & PCRE_IMS))
-               {
-               *code++ = OP_OPT;
-               *code++ = newoptions & PCRE_IMS;
-               }
              greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
              greedy_non_default = greedy_default ^ 1;
              req_caseopt = ((newoptions & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
-Line 5285 
 we set the flag only if there is a liter
+Line 5752 
 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 5478 
 we set the flag only if there is a liter
+Line 5945 
 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 5590 
 we set the flag only if there is a liter
+Line 6058 
 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 */
          if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
          previous = code;
-         *code++ = OP_REF;
+         *code++ = ((options & PCRE_CASELESS) != 0)? OP_REFI : OP_REF;
          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 5628 
 we set the flag only if there is a liter
+Line 6110 
 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 5678 
 we set the flag only if there is a liter
+Line 6172 
 we set the flag only if there is a liter
      ONE_CHAR:
      previous = code;
-     *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARNC : OP_CHAR;
+     *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARI : OP_CHAR;
      for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];
      /* Remember if \r or \n were seen */
-Line 5742 
 return FALSE;
+Line 6236 
 return FALSE;
  /* On entry, ptr is pointing past the bracket character, but on return it
  points to the closing bracket, or vertical bar, or end of string. The code
  variable is pointing at the byte into which the BRA operator has been stored.
- If the ims options are changed at the start (for a (?ims: group) or during any
- branch, we need to insert an OP_OPT item at the start of every following branch
- to ensure they get set correctly at run time, and also pass the new options
- into every subsequent branch compile.
  This function is used during the pre-compile phase when we are trying to find
  out the amount of memory needed, as well as during the real compile phase. The
  value of lengthptr distinguishes the two phases.
-Line 5811 
 them global. It tests the value of lengt
+Line 6300 
 them global. It tests the value of lengt
  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. */
+ 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;
    }
-Line 5836 
 for (;;)
+Line 6327 
 for (;;)
    if (reset_bracount) cd->bracount = orig_bracount;
-   /* Handle a change of ims options at the start of the branch */
-   if ((options & PCRE_IMS) != oldims)
-     {
-     *code++ = OP_OPT;
-     *code++ = options & PCRE_IMS;
-     length += 2;
-     }
    /* Set up dummy OP_REVERSE if lookbehind assertion */
    if (lookbehind)
-Line 5963 
 for (;;)
+Line 6445 
 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 5974 
 for (;;)
+Line 6456 
 for (;;)
        while (branch_length > 0);
        }
-     /* If it was a capturing subpattern, remove it from the chain. */
-     if (capnumber > 0) cd->open_caps = cd->open_caps->next;
      /* Fill in the ket */
      *code = OP_KET;
-     PUT(code, 1, code - start_bracket);
+     PUT(code, 1, (int)(code - start_bracket));
      code += 1 + LINK_SIZE;
-     /* Reset options if needed. */
+     /* If it was a capturing subpattern, check to see if it contained any
+     recursive back references. If so, we must wrap it in atomic brackets.
+     In any event, remove the block from the chain. */
-     if ((options & PCRE_IMS) != oldims && *ptr == CHAR_RIGHT_PARENTHESIS)
+     if (capnumber > 0)
        {
-       *code++ = OP_OPT;
+       if (cd->open_caps->flag)
-       *code++ = oldims;
+         {
-       length += 2;
+         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;
        }
      /* Retain the highest bracket number, in case resetting was used. */
-Line 6032 
 for (;;)
+Line 6522 
 for (;;)
    else
      {
      *code = OP_ALT;
-     PUT(code, 1, code - last_branch);
+     PUT(code, 1, (int)(code - last_branch));
      bc.current_branch = last_branch = code;
      code += 1 + LINK_SIZE;
      }
-Line 6052 
 for (;;)
+Line 6542 
 for (;;)
  /* Try to find out if this is an anchored regular expression. Consider each
  alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
  all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
- it's anchored. However, if this is a multiline pattern, then only OP_SOD
+ it's anchored. However, if this is a multiline pattern, then only OP_SOD will
- counts, since OP_CIRC can match in the middle.
+ be found, because ^ generates OP_CIRCM in that mode.
  We can also consider a regex to be anchored if OP_SOM starts all its branches.
  This is the code for \G, which means "match at start of match position, taking
-Line 6127 
 do {
+Line 6617 
 do {
     /* Check for explicit anchoring */
-    else if (op != OP_SOD && op != OP_SOM &&
+    else if (op != OP_SOD && op != OP_SOM && op != OP_CIRC) return FALSE;
-            ((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
-      return FALSE;
     code += GET(code, 1);
     }
  while (*code == OP_ALT);   /* Loop for each alternative */
-Line 6229 
 do {
+Line 6717 
 do {
     /* Check for explicit circumflex */
-    else if (op != OP_CIRC) return FALSE;
+    else if (op != OP_CIRC && op != OP_CIRCM) return FALSE;
     /* Move on to the next alternative */
-Line 6290 
 do {
+Line 6778 
 do {
       scode += 2;
       case OP_CHAR:
-      case OP_CHARNC:
+      case OP_CHARI:
       case OP_PLUS:
       case OP_MINPLUS:
       case OP_POSPLUS:
-Line 6351 
 int length = 1;  /* For final END opcode
+Line 6839 
 int length = 1;  /* For final END opcode
  int firstbyte, reqbyte, newline;
  int errorcode = 0;
  int skipatstart = 0;
- BOOL utf8 = (options & PCRE_UTF8) != 0;
+ BOOL utf8;
  size_t size;
  uschar *code;
  const uschar *codestart;
-Line 6421 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 6909 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
    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; }
+   else if (strncmp((char *)(ptr+skipatstart+2), STRING_NO_START_OPT_RIGHTPAR, 13) == 0)
+     { skipatstart += 15; options |= PCRE_NO_START_OPTIMIZE; continue; }
    if (strncmp((char *)(ptr+skipatstart+2), STRING_CR_RIGHTPAR, 3) == 0)
      { skipatstart += 5; newnl = PCRE_NEWLINE_CR; }
-Line 6445 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 6937 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
    else break;
    }
- /* Can't support UTF8 unless PCRE has been compiled to include the code. */
+ utf8 = (options & PCRE_UTF8) != 0;
+ /* Can't support UTF8 unless PCRE has been compiled to include the code. The
+ return of an error code from _pcre_valid_utf8() is a new feature, introduced in
+ release 8.13. The only use we make of it here is to adjust the offset value to
+ the end of the string for a short string error, for compatibility with previous
+ versions. */
  #ifdef SUPPORT_UTF8
  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
-      (*erroroffset = _pcre_valid_utf8((USPTR)pattern, -1)) >= 0)
+      (*erroroffset = _pcre_valid_utf8((USPTR)pattern, -1, &errorcode)) >= 0)
    {
    errorcode = ERR44;
    goto PCRE_EARLY_ERROR_RETURN2;
-Line 6462 
 if (utf8)
+Line 6960 
 if (utf8)
    }
  #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. */
  switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
-Line 6590 
 regex compiled on a system with 4-byte p
+Line 7098 
 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 6661 
 while (errorcode == 0 && cd->hwm > cwork
+Line 7169 
 while (errorcode == 0 && cd->hwm > cwork
    recno = GET(codestart, offset);
    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 6716 
 if (errorcode != 0)
+Line 7224 
 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 6771 
 if (reqbyte >= 0 &&
+Line 7279 
 if (reqbyte >= 0 &&
  case when building a production library. */
  #ifdef PCRE_DEBUG
  printf("Length = %d top_bracket = %d top_backref = %d\n",
    length, re->top_bracket, re->top_backref);

 Legend:



Removed from v.483
 


changed lines


 
Added in v.602
 Legend:



Removed from v.483
 


changed lines


 
Added in v.602
-Removed from v.483
+Added in v.602

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12