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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 532 by ph10,
Tue Jun  1 16:21:42 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 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
 Line 272 
 static const uschar *substitutes[] = {
    (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 */
 Line 289 
 static const uschar *posix_substitutes[]
    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 */
 Line 304 
 static const uschar *posix_substitutes[]
    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 407 
 static const char error_texts[] =
    /* 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"
+   "\\c must be followed by an ASCII character\0"
    ;
  /* Table to identify digits and hex digits. This is used when compiling
-Line 841 
 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 851 
 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 1099 
 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 1110 
 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 1117 
 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 1129 
 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 1159 
 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 1188 
 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 1264 
 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 1273 
 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 1281 
 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 1320 
 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 1338 
 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 1354 
 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 1376 
 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 1518 
 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:
-Line 1526 
 for (;;)
+Line 1562 
 for (;;)
      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 1535 
 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 1711 
 for (;;)
+Line 1750 
 for (;;)
        case OP_MARK:
        case OP_PRUNE_ARG:
        case OP_SKIP_ARG:
-       case OP_THEN_ARG:
        code += code[1];
        break;
+       case OP_THEN_ARG:
+       code += code[1+LINK_SIZE];
+       break;
        }
      /* Add in the fixed length from the table */
-Line 1728 
 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 1814 
 for (;;)
+Line 1869 
 for (;;)
        case OP_MARK:
        case OP_PRUNE_ARG:
        case OP_SKIP_ARG:
-       case OP_THEN_ARG:
        code += code[1];
        break;
+       case OP_THEN_ARG:
+       code += code[1+LINK_SIZE];
+       break;
        }
      /* Add in the fixed length from the table */
-Line 1831 
 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 2022 
 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 2071 
 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
-Line 2092 
 for (code = first_significant_code(code
+Line 2173 
 for (code = first_significant_code(code
      case OP_MARK:
      case OP_PRUNE_ARG:
      case OP_SKIP_ARG:
-     case OP_THEN_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:
-Line 2407 
 Arguments:
+Line 2491 
 Arguments:
    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)
-Line 2453 
 switch(ptype)
+Line 2537 
 switch(ptype)
            _pcre_ucp_gentype[prop->chartype] == ucp_N ||
            c == CHAR_UNDERSCORE) == negated;
    }
  return FALSE;
  }
  #endif  /* SUPPORT_UCP */
-Line 2478 
 Returns:        TRUE if possessifying is
+Line 2562 
 Returns:        TRUE if possessifying is
  */
  static BOOL
  check_auto_possessive(const uschar *previous, BOOL utf8, const uschar *ptr,
    int options, compile_data *cd)
  {
  int c, next;
-Line 2493 
 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 2530 
 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 2549 
 the next item is a character. */
+Line 2647 
 the next item is a character. */
  if (next >= 0) switch(op_code)
    {
    case OP_CHAR:
  #ifdef SUPPORT_UTF8
    GETCHARTEST(c, previous);
  #else
    c = *previous;
  #endif
    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
    GETCHARTEST(c, previous);
  #else
    c = *previous;
  #endif
    if (c == next) return FALSE;
  #ifdef SUPPORT_UTF8
    if (utf8)
-Line 2583 
 if (next >= 0) switch(op_code)
+Line 2681 
 if (next >= 0) switch(op_code)
  #endif  /* SUPPORT_UTF8 */
    return (c != cd->fcc[next]);  /* Non-UTF-8 mode */
-   /* For OP_NOT, its data is always 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:
+   return (c = *previous) == next;
+   case OP_NOTI:
    if ((c = *previous) == next) return TRUE;
-   if ((options & PCRE_CASELESS) == 0) return FALSE;
  #ifdef SUPPORT_UTF8
    if (utf8)
      {
-Line 2603 
 if (next >= 0) switch(op_code)
+Line 2705 
 if (next >= 0) switch(op_code)
    else
  #endif  /* SUPPORT_UTF8 */
    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 2673 
 if (next >= 0) switch(op_code)
+Line 2775 
 if (next >= 0) switch(op_code)
  #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
-Line 2683 
 if (next >= 0) switch(op_code)
+Line 2785 
 if (next >= 0) switch(op_code)
    }
  /* 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
    GETCHARTEST(c, previous);
  #else
    c = *previous;
  #endif
    switch(-next)
      {
      case ESC_d:
-Line 2761 
 switch(op_code)
+Line 2863 
 switch(op_code)
        default:
        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:
-Line 2780 
 switch(op_code)
+Line 2882 
 switch(op_code)
        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 ||
-Line 2831 
 switch(op_code)
+Line 2933 
 switch(op_code)
    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 || 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;
-Line 2846 
 switch(op_code)
+Line 2948 
 switch(op_code)
    return next == -ESC_v || next == -ESC_R;
    case OP_WORDCHAR:
    return next == -ESC_W || next == -ESC_s || next == -ESC_h ||
           next == -ESC_v || next == -ESC_R;
    case OP_NOT_WORDCHAR:
-Line 2982 
 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)
-Line 3104 
 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 3151 
 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 3289 
 for (;; ptr++)
+Line 3397 
 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 3358 
 for (;; ptr++)
+Line 3466 
 for (;; ptr++)
          if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
            posix_class = 0;
          /* When PCRE_UCP is set, some of the POSIX classes are converted to
          different escape sequences that use Unicode properties. */
  #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.
-Line 3460 
 for (;; ptr++)
+Line 3568 
 for (;; ptr++)
              case ESC_SU:
              nestptr = ptr;
              ptr = substitutes[-c - ESC_DU] - 1;  /* Just before substitute */
              class_charcount -= 2;                /* Undo! */
              continue;
  #endif
              case ESC_d:
-Line 3481 
 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 3902 
 for (;; ptr++)
+Line 4015 
 for (;; ptr++)
      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 &&
        (!utf8 || !negate_class || class_lastchar < 128))
-Line 3921 
 for (;; ptr++)
+Line 4034 
 for (;; ptr++)
        {
        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 3991 
 for (;; ptr++)
+Line 4104 
 for (;; ptr++)
        }
  #endif
      /* If there are no characters > 255, or they are all to be included or
      excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the
      whole class was negated and whether there were negative specials such as \S
      (non-UCP) in the class. Then copy the 32-byte map into the code vector,
-Line 4085 
 for (;; ptr++)
+Line 4198 
 for (;; ptr++)
      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 4131 
 for (;; ptr++)
+Line 4246 
 for (;; ptr++)
      /* 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 &&
-Line 4333 
 for (;; ptr++)
+Line 4448 
 for (;; ptr++)
  #ifdef SUPPORT_UTF8
               *previous == OP_XCLASS ||
  #endif
-              *previous == OP_REF)
+              *previous == OP_REF ||
+              *previous == OP_REFI)
        {
        if (repeat_max == 0)
          {
-Line 4387 
 for (;; ptr++)
+Line 4503 
 for (;; ptr++)
        /* 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)
          {
-Line 4689 
 for (;; ptr++)
+Line 4803 
 for (;; ptr++)
          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. */
-Line 4757 
 for (;; ptr++)
+Line 4881 
 for (;; ptr++)
          arg = ++ptr;
          while ((cd->ctypes[*ptr] & (ctype_letter|ctype_digit)) != 0
            || *ptr == '_') ptr++;
-         arglen = ptr - arg;
+         arglen = (int)(ptr - arg);
          }
        if (*ptr != CHAR_RIGHT_PARENTHESIS)
-Line 4795 
 for (;; ptr++)
+Line 4919 
 for (;; ptr++)
                *errorcodeptr = ERR66;
                goto FAILED;
                }
-             *code++ = verbs[i].op;
+             *code = verbs[i].op;
+             if (*code++ == OP_THEN)
+               {
+               PUT(code, 0, code - bcptr->current_branch - 1);
+               code += LINK_SIZE;
+               }
              }
            else
-Line 4805 
 for (;; ptr++)
+Line 4934 
 for (;; ptr++)
                *errorcodeptr = ERR59;
                goto FAILED;
                }
-             *code++ = verbs[i].op_arg;
+             *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;
-Line 4999 
 for (;; ptr++)
+Line 5133 
 for (;; ptr++)
          /* 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 5300 
 for (;; ptr++)
+Line 5434 
 for (;; ptr++)
          while ((cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
          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 5320 
 for (;; ptr++)
+Line 5460 
 for (;; ptr++)
              *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 5345 
 for (;; ptr++)
+Line 5500 
 for (;; ptr++)
              }
            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 5456 
 for (;; ptr++)
+Line 5611 
 for (;; ptr++)
              if (called == NULL)
                {
                if (find_parens(cd, NULL, recno,
-                     (options & PCRE_EXTENDED) != 0) < 0)
+                     (options & PCRE_EXTENDED) != 0, utf8) < 0)
                  {
                  *errorcodeptr = ERR15;
                  goto FAILED;
-Line 5572 
 for (;; ptr++)
+Line 5727 
 for (;; ptr++)
              }
            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 5795 
 for (;; ptr++)
+Line 5945 
 for (;; ptr++)
      /* ===================================================================*/
      /* Handle metasequences introduced by \. For ones like \d, the ESC_ values
      are arranged to be the negation of the corresponding OP_values in the
      default case when PCRE_UCP is not set. For the back references, the values
      are ESC_REF plus the reference number. Only back references and those types
      that consume a character may be repeated. We can test for values between
-Line 5914 
 for (;; ptr++)
+Line 6064 
 for (;; ptr++)
          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;
-Line 5973 
 for (;; ptr++)
+Line 6123 
 for (;; ptr++)
            ptr = substitutes[-c - ESC_DU] - 1;  /* Just before substitute */
            }
          else
  #endif
            {
            previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;
            *code++ = -c;
            }
          }
        continue;
        }
-Line 6022 
 for (;; ptr++)
+Line 6172 
 for (;; ptr++)
      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 6086 
 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 6182 
 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 6347 
 for (;;)
+Line 6483 
 for (;;)
        cd->open_caps = cd->open_caps->next;
        }
-     /* Reset options if needed. */
-     if ((options & PCRE_IMS) != oldims && *ptr == CHAR_RIGHT_PARENTHESIS)
-       {
-       *code++ = OP_OPT;
-       *code++ = oldims;
-       length += 2;
-       }
      /* Retain the highest bracket number, in case resetting was used. */
      cd->bracount = max_bracount;
-Line 6415 
 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 6490 
 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 6592 
 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 6653 
 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 6786 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 6911 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
      { 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 6809 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 6936 
 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. */
+ /* 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 6835 
 if (utf8)
+Line 6966 
 if (utf8)
  if ((options & PCRE_UCP) != 0)
    {
    errorcode = ERR67;
    goto PCRE_EARLY_ERROR_RETURN;
    }
  #endif
  /* Check validity of \R options. */

 Legend:



Removed from v.532
 


changed lines


 
Added in v.602
 Legend:



Removed from v.532
 


changed lines


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

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12