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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 962 by ph10,
Fri Apr 20 17:28:23 2012 UTC
+revision 1055 by chpe,
Tue Oct 16 15:53:30 2012 UTC
 Line 53 
 supporting internal functions that are n
  #include "pcre_internal.h"
- /* When PCRE_DEBUG is defined, we need the pcre(16)_printint() function, which
+ /* When PCRE_DEBUG is defined, we need the pcre(16|32)_printint() function, which
  is also used by pcretest. PCRE_DEBUG is not defined when building a production
  library. We do not need to select pcre16_printint.c specially, because the
  COMPILE_PCREx macro will already be appropriately set. */
 Line 68 
 COMPILE_PCREx macro will already be appr
  /* Macro for setting individual bits in class bitmaps. */
- #define SETBIT(a,b) a[b/8] |= (1 << (b%8))
+ #define SETBIT(a,b) a[(b)/8] |= (1 << ((b)&7))
  /* Maximum length value to check against when making sure that the integer that
  holds the compiled pattern length does not overflow. We make it a bit less than
 Line 77 
 to check them every time. */
  #define OFLOW_MAX (INT_MAX - 20)
+ /* Definitions to allow mutual recursion */
+ static int
+   add_list_to_class(pcre_uint8 *, pcre_uchar **, int, compile_data *,
+     const pcre_uint32 *, unsigned int);
+ static BOOL
+   compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL,
+     int, int, int *, int *, branch_chain *, compile_data *, int *);
  /*************************************************
  *      Code parameters and static tables         *
-Line 112 
 overrun before it actually does run off
+Line 123 
 overrun before it actually does run off
  #define REQ_CASELESS   0x10000000l      /* Indicates caselessness */
  #define REQ_VARY       0x20000000l      /* Reqchar followed non-literal item */
+ #define REQ_MASK       (REQ_CASELESS | REQ_VARY)
  /* Repeated character flags. */
-Line 489 
 static const char error_texts[] =
+Line 501 
 static const char error_texts[] =
    "too many forward references\0"
    "disallowed Unicode code point (>= 0xd800 && <= 0xdfff)\0"
    "invalid UTF-16 string\0"
+   /* 75 */
+   "name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)\0"
+   "character value in \\u.... sequence is too large\0"
+   "invalid UTF-32 string\0"
    ;
  /* Table to identify digits and hex digits. This is used when compiling
-Line 628 
 static const pcre_uint8 ebcdic_chartab[]
+Line 644 
 static const pcre_uint8 ebcdic_chartab[]
  #endif
- /* Definition to allow mutual recursion */
- static BOOL
-   compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL, int, int,
-     int *, int *, branch_chain *, compile_data *, int *);
  /*************************************************
-Line 786 
 else if ((i = escapes[c - CHAR_0]) != 0)
+Line 796 
 else if ((i = escapes[c - CHAR_0]) != 0)
  #else           /* EBCDIC coding */
  /* Not alphanumeric */
- else if (c < 'a' || (!MAX_255(c) || (ebcdic_chartab[c] & 0x0E) == 0)) {}
+ else if (c < CHAR_a || (!MAX_255(c) || (ebcdic_chartab[c] & 0x0E) == 0)) {}
  else if ((i = escapes[c - 0x48]) != 0)  c = i;
  #endif
-Line 829 
 else
+Line 839 
 else
            c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
  #endif
            }
+ #if defined COMPILE_PCRE8
+         if (c > (utf ? 0x10ffff : 0xff))
+ #elif defined COMPILE_PCRE16
+         if (c > (utf ? 0x10ffff : 0xffff))
+ #elif defined COMPILE_PCRE32
+         if (utf && c > 0x10ffff)
+ #endif
+           {
+           *errorcodeptr = ERR76;
+           }
+         else if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
          }
        }
      else
-Line 1049 
 else
+Line 1071 
 else
          c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
  #endif
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
          if (c > (utf ? 0x10ffff : 0xff)) { c = -1; break; }
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
          if (c > (utf ? 0x10ffff : 0xffff)) { c = -1; break; }
- #endif
+ #elif defined COMPILE_PCRE32
+         if (utf && c > 0x10ffff) { c = -1; break; }
  #endif
          }
-Line 1347 
 Arguments:
+Line 1369 
 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
-   utf          TRUE if we are in UTF-8 / UTF-16 mode
+   utf          TRUE if we are in UTF-8 / UTF-16 / UTF-32 mode
    count        pointer to the current capturing subpattern number (updated)
  Returns:       the number of the named subpattern, or -1 if not found
-Line 1581 
 Arguments:
+Line 1603 
 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
-   utf          TRUE if we are in UTF-8 / UTF-16 mode
+   utf          TRUE if we are in UTF-8 / UTF-16 / UTF-32 mode
  Returns:       the number of the found subpattern, or -1 if not found
  */
-Line 1684 
 and doing the check at the end; a flag s
+Line 1706 
 and doing the check at the end; a flag s
  Arguments:
    code     points to the start of the pattern (the bracket)
-   utf      TRUE in UTF-8 / UTF-16 mode
+   utf      TRUE in UTF-8 / UTF-16 / UTF-32 mode
    atend    TRUE if called when the pattern is complete
    cd       the "compile data" structure
-Line 1818 
 for (;;)
+Line 1840 
 for (;;)
      case OP_NOTI:
      branchlength++;
      cc += 2;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
      break;
-Line 1832 
 for (;;)
+Line 1854 
 for (;;)
      case OP_NOTEXACTI:
      branchlength += GET2(cc,1);
      cc += 2 + IMM2_SIZE;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
      break;
      case OP_TYPEEXACT:
      branchlength += GET2(cc,1);
-     if (cc[1 + IMM2_SIZE] == OP_PROP || cc[1 + IMM2_SIZE] == OP_NOTPROP) cc += 2;
+     if (cc[1 + IMM2_SIZE] == OP_PROP || cc[1 + IMM2_SIZE] == OP_NOTPROP)
+       cc += 2;
      cc += 1 + IMM2_SIZE + 1;
      break;
-Line 1874 
 for (;;)
+Line 1897 
 for (;;)
      /* Check a class for variable quantification */
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
      case OP_XCLASS:
      cc += GET(cc, 1) - PRIV(OP_lengths)[OP_CLASS];
      /* Fall through */
-Line 2013 
 length.
+Line 2036 
 length.
  Arguments:
    code        points to start of expression
-   utf         TRUE in UTF-8 / UTF-16 mode
+   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
    number      the required bracket number or negative to find a lookbehind
  Returns:      pointer to the opcode for the bracket, or NULL if not found
-Line 2077 
 for (;;)
+Line 2100 
 for (;;)
        case OP_TYPEMINUPTO:
        case OP_TYPEEXACT:
        case OP_TYPEPOSUPTO:
-       if (code[1 + IMM2_SIZE] == OP_PROP
+       if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
-         || code[1 + IMM2_SIZE] == OP_NOTPROP) code += 2;
+         code += 2;
        break;
        case OP_MARK:
-Line 2100 
 for (;;)
+Line 2123 
 for (;;)
    a multi-byte character. The length in the table is a minimum, so we have to
    arrange to skip the extra bytes. */
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (utf) switch(c)
        {
        case OP_CHAR:
-Line 2152 
 instance of OP_RECURSE.
+Line 2175 
 instance of OP_RECURSE.
  Arguments:
    code        points to start of expression
-   utf         TRUE in UTF-8 / UTF-16 mode
+   utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
  Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
  */
-Line 2197 
 for (;;)
+Line 2220 
 for (;;)
        case OP_TYPEUPTO:
        case OP_TYPEMINUPTO:
        case OP_TYPEEXACT:
-       if (code[1 + IMM2_SIZE] == OP_PROP
+       if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
-         || code[1 + IMM2_SIZE] == OP_NOTPROP) code += 2;
+         code += 2;
        break;
        case OP_MARK:
-Line 2220 
 for (;;)
+Line 2243 
 for (;;)
      by a multi-byte character. The length in the table is a minimum, so we have
      to arrange to skip the extra bytes. */
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (utf) switch(c)
        {
        case OP_CHAR:
-Line 2306 
 bracket whose current branch will alread
+Line 2329 
 bracket whose current branch will alread
  Arguments:
    code        points to start of search
    endcode     points to where to stop
-   utf         TRUE if in UTF-8 / UTF-16 mode
+   utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
    cd          contains pointers to tables etc.
  Returns:      TRUE if what is matched could be empty
-Line 2523 
 for (code = first_significant_code(code
+Line 2546 
 for (code = first_significant_code(code
      case OP_TYPEUPTO:
      case OP_TYPEMINUPTO:
      case OP_TYPEPOSUPTO:
-     if (code[1 + IMM2_SIZE] == OP_PROP
+     if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
-       || code[1 + IMM2_SIZE] == OP_NOTPROP) code += 2;
+       code += 2;
      break;
      /* End of branch */
-Line 2539 
 for (code = first_significant_code(code
+Line 2562 
 for (code = first_significant_code(code
      /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,
      MINUPTO, and POSUPTO may be followed by a multibyte character */
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      case OP_STAR:
      case OP_STARI:
      case OP_MINSTAR:
-Line 2605 
 Arguments:
+Line 2628 
 Arguments:
    code        points to start of the recursion
    endcode     points to where to stop (current RECURSE item)
    bcptr       points to the chain of current (unclosed) branch starts
-   utf         TRUE if in UTF-8 / UTF-16 mode
+   utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
    cd          pointers to tables etc
  Returns:      TRUE if what is matched could be empty
-Line 2752 
 value in the reference (which is a group
+Line 2775 
 value in the reference (which is a group
  Arguments:
    group      points to the start of the group
    adjust     the amount by which the group is to be moved
-   utf        TRUE in UTF-8 / UTF-16 mode
+   utf        TRUE in UTF-8 / UTF-16 / UTF-32 mode
    cd         contains pointers to tables etc.
    save_hwm   the hwm forward reference pointer at the start of the group
-Line 2856 
 PUT(previous_callout, 2 + LINK_SIZE, len
+Line 2879 
 PUT(previous_callout, 2 + LINK_SIZE, len
  *************************************************/
  /* This function is passed the start and end of a class range, in UTF-8 mode
- with UCP support. It searches up the characters, looking for internal ranges of
+ with UCP support. It searches up the characters, looking for ranges of
  characters in the "other" case. Each call returns the next one, updating the
- start address.
+ start address. A character with multiple other cases is returned on its own
+ with a special return value.
  Arguments:
    cptr        points to starting character value; updated
-Line 2866 
 Arguments:
+Line 2890 
 Arguments:
    ocptr       where to put start of othercase range
    odptr       where to put end of othercase range
- Yield:        TRUE when range returned; FALSE when no more
+ Yield:        -1 when no more
+when a range is returned
+               >0 the CASESET offset for char with multiple other cases
+                 in this case, ocptr contains the original
  */
- static BOOL
+ static int
  get_othercase_range(unsigned int *cptr, unsigned int d, unsigned int *ocptr,
    unsigned int *odptr)
  {
  unsigned int c, othercase, next;
+ int co;
+ /* Find the first character that has an other case. If it has multiple other
+ cases, return its case offset value. */
  for (c = *cptr; c <= d; c++)
-   { if ((othercase = UCD_OTHERCASE(c)) != c) break; }
+   {
+   if ((co = UCD_CASESET(c)) != 0)
+     {
+     *ocptr = c++;   /* Character that has the set */
+     *cptr = c;      /* Rest of input range */
+     return co;
+     }
+   if ((othercase = UCD_OTHERCASE(c)) != c) break;
+   }
- if (c > d) return FALSE;
+ if (c > d) return -1;  /* Reached end of range */
  *ocptr = othercase;
  next = othercase + 1;
-Line 2889 
 for (++c; c <= d; c++)
+Line 2928 
 for (++c; c <= d; c++)
    next++;
    }
- *odptr = next - 1;
+ *odptr = next - 1;     /* End of othercase range */
- *cptr = c;
+ *cptr = c;             /* Rest of input range */
+ return 0;
- return TRUE;
  }
-Line 2916 
 Returns:       TRUE if auto-possessifyin
+Line 2954 
 Returns:       TRUE if auto-possessifyin
  static BOOL
  check_char_prop(int c, int ptype, int pdata, BOOL negated)
  {
+ #ifdef SUPPORT_UCP
+ const pcre_uint32 *p;
+ #endif
  const ucd_record *prop = GET_UCD(c);
  switch(ptype)
    {
    case PT_LAMP:
-Line 2954 
 switch(ptype)
+Line 2997 
 switch(ptype)
    return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
            PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
            c == CHAR_UNDERSCORE) == negated;
+ #ifdef SUPPORT_UCP
+   case PT_CLIST:
+   p = PRIV(ucd_caseless_sets) + prop->caseset;
+   for (;;)
+     {
+     if ((unsigned int)c < *p) return !negated;
+     if ((unsigned int)c == *p++) return negated;
+     }
+   break;  /* Control never reaches here */
+ #endif
    }
  return FALSE;
  }
  #endif  /* SUPPORT_UCP */
-Line 2971 
 sense to automatically possessify the re
+Line 3026 
 sense to automatically possessify the re
  Arguments:
    previous      pointer to the repeated opcode
-   utf           TRUE in UTF-8 / UTF-16 mode
+   utf           TRUE in UTF-8 / UTF-16 / UTF-32 mode
    ptr           next character in pattern
    options       options bits
    cd            contains pointers to tables etc.
-Line 2983 
 static BOOL
+Line 3038 
 static BOOL
  check_auto_possessive(const pcre_uchar *previous, BOOL utf,
    const pcre_uchar *ptr, int options, compile_data *cd)
  {
- pcre_int32 c, next;
+ pcre_int32 c = NOTACHAR;
+ pcre_int32 next;
  int op_code = *previous++;
  /* Skip whitespace and comments in extended mode */
-Line 3057 
 if (*ptr == CHAR_ASTERISK || *ptr == CHA
+Line 3113 
 if (*ptr == CHAR_ASTERISK || *ptr == CHA
    STRNCMP_UC_C8(ptr, STR_LEFT_CURLY_BRACKET STR_0 STR_COMMA, 3) == 0)
      return FALSE;
- /* Now compare the next item with the previous opcode. First, handle cases when
+ /* If the previous item is a character, get its value. */
- the next item is a character. */
- if (next >= 0) switch(op_code)
+ if (op_code == OP_CHAR || op_code == OP_CHARI ||
+     op_code == OP_NOT || op_code == OP_NOTI)
    {
-   case OP_CHAR:
  #ifdef SUPPORT_UTF
    GETCHARTEST(c, previous);
  #else
    c = *previous;
  #endif
-   return c != next;
+   }
-   /* For CHARI (caseless character) we must check the other case. If we have
+ /* Now compare the next item with the previous opcode. First, handle cases when
-   Unicode property support, we can use it to test the other case of
+ the next item is a character. */
-   high-valued characters. */
-   case OP_CHARI:
+ if (next >= 0)
- #ifdef SUPPORT_UTF
+   {
-   GETCHARTEST(c, previous);
+   /* For a caseless UTF match, the next character may have more than one other
- #else
+   case, which maps to the special PT_CLIST property. Check this first. */
-   c = *previous;
- #endif
-   if (c == next) return FALSE;
- #ifdef SUPPORT_UTF
-   if (utf)
-     {
-     unsigned int othercase;
-     if (next < 128) othercase = cd->fcc[next]; else
  #ifdef SUPPORT_UCP
-     othercase = UCD_OTHERCASE((unsigned int)next);
+   if (utf && (unsigned int)c != NOTACHAR && (options & PCRE_CASELESS) != 0)
- #else
+     {
-     othercase = NOTACHAR;
+     int ocs = UCD_CASESET(next);
- #endif
+     if (ocs > 0) return check_char_prop(c, PT_CLIST, ocs, op_code >= OP_NOT);
-     return (unsigned int)c != othercase;
      }
-   else
- #endif  /* SUPPORT_UTF */
-   return (c != TABLE_GET((unsigned int)next, cd->fcc, next));  /* Non-UTF-8 mode */
-   case OP_NOT:
- #ifdef SUPPORT_UTF
-   GETCHARTEST(c, previous);
- #else
-   c = *previous;
  #endif
-   return c == next;
-   case OP_NOTI:
+   switch(op_code)
+     {
+     case OP_CHAR:
+     return c != next;
+     /* 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. We know that next can have only one other case,
+     because multi-other-case characters are dealt with above. */
+     case OP_CHARI:
+     if (c == next) return FALSE;
  #ifdef SUPPORT_UTF
-   GETCHARTEST(c, previous);
+     if (utf)
+       {
+       unsigned int othercase;
+       if (next < 128) othercase = cd->fcc[next]; else
+ #ifdef SUPPORT_UCP
+       othercase = UCD_OTHERCASE((unsigned int)next);
  #else
-   c = *previous;
+       othercase = NOTACHAR;
  #endif
-   if (c == next) return TRUE;
+       return (unsigned int)c != othercase;
+       }
+     else
+ #endif  /* SUPPORT_UTF */
+     return (c != TABLE_GET((unsigned int)next, cd->fcc, next));  /* Not UTF */
+     case OP_NOT:
+     return c == next;
+     case OP_NOTI:
+     if (c == next) return TRUE;
  #ifdef SUPPORT_UTF
-   if (utf)
+     if (utf)
-     {
+       {
-     unsigned int othercase;
+       unsigned int othercase;
-     if (next < 128) othercase = cd->fcc[next]; else
+       if (next < 128) othercase = cd->fcc[next]; else
  #ifdef SUPPORT_UCP
-     othercase = UCD_OTHERCASE((unsigned int)next);
+       othercase = UCD_OTHERCASE((unsigned int)next);
  #else
-     othercase = NOTACHAR;
+       othercase = NOTACHAR;
  #endif
-     return (unsigned int)c == othercase;
+       return (unsigned int)c == othercase;
-     }
+       }
-   else
+     else
  #endif  /* SUPPORT_UTF */
-   return (c == TABLE_GET((unsigned int)next, cd->fcc, next));  /* Non-UTF-8 mode */
+     return (c == TABLE_GET((unsigned int)next, cd->fcc, next));  /* Not UTF */
-   /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not* set.
+     /* 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. */
+     When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
-   case OP_DIGIT:
+     case OP_DIGIT:
-   return next > 255 || (cd->ctypes[next] & ctype_digit) == 0;
+     return next > 255 || (cd->ctypes[next] & ctype_digit) == 0;
-   case OP_NOT_DIGIT:
+     case OP_NOT_DIGIT:
-   return next <= 255 && (cd->ctypes[next] & ctype_digit) != 0;
+     return next <= 255 && (cd->ctypes[next] & ctype_digit) != 0;
-   case OP_WHITESPACE:
+     case OP_WHITESPACE:
-   return next > 255 || (cd->ctypes[next] & ctype_space) == 0;
+     return next > 255 || (cd->ctypes[next] & ctype_space) == 0;
-   case OP_NOT_WHITESPACE:
+     case OP_NOT_WHITESPACE:
-   return next <= 255 && (cd->ctypes[next] & ctype_space) != 0;
+     return next <= 255 && (cd->ctypes[next] & ctype_space) != 0;
-   case OP_WORDCHAR:
+     case OP_WORDCHAR:
-   return next > 255 || (cd->ctypes[next] & ctype_word) == 0;
+     return next > 255 || (cd->ctypes[next] & ctype_word) == 0;
-   case OP_NOT_WORDCHAR:
+     case OP_NOT_WORDCHAR:
-   return next <= 255 && (cd->ctypes[next] & ctype_word) != 0;
+     return next <= 255 && (cd->ctypes[next] & ctype_word) != 0;
-   case OP_HSPACE:
+     case OP_HSPACE:
-   case OP_NOT_HSPACE:
+     case OP_NOT_HSPACE:
-   switch(next)
+     switch(next)
-     {
+       {
-     case 0x09:
+       HSPACE_CASES:
-     case 0x20:
+       return op_code == OP_NOT_HSPACE;
-     case 0xa0:
-     case 0x1680:
-     case 0x180e:
-     case 0x2000:
-     case 0x2001:
-     case 0x2002:
-     case 0x2003:
-     case 0x2004:
-     case 0x2005:
-     case 0x2006:
-     case 0x2007:
-     case 0x2008:
-     case 0x2009:
-     case 0x200A:
-     case 0x202f:
-     case 0x205f:
-     case 0x3000:
-     return op_code == OP_NOT_HSPACE;
-     default:
-     return op_code != OP_NOT_HSPACE;
-     }
-   case OP_ANYNL:
+       default:
-   case OP_VSPACE:
+       return op_code != OP_NOT_HSPACE;
-   case OP_NOT_VSPACE:
+       }
-   switch(next)
-     {
+     case OP_ANYNL:
-     case 0x0a:
+     case OP_VSPACE:
-     case 0x0b:
+     case OP_NOT_VSPACE:
-     case 0x0c:
+     switch(next)
-     case 0x0d:
+       {
-     case 0x85:
+       VSPACE_CASES:
-     case 0x2028:
+       return op_code == OP_NOT_VSPACE;
-     case 0x2029:
-     return op_code == OP_NOT_VSPACE;
+       default:
-     default:
+       return op_code != OP_NOT_VSPACE;
-     return op_code != OP_NOT_VSPACE;
+       }
-     }
  #ifdef SUPPORT_UCP
-   case OP_PROP:
+     case OP_PROP:
-   return check_char_prop(next, previous[0], previous[1], FALSE);
+     return check_char_prop(next, previous[0], previous[1], FALSE);
-   case OP_NOTPROP:
+     case OP_NOTPROP:
-   return check_char_prop(next, previous[0], previous[1], TRUE);
+     return check_char_prop(next, previous[0], previous[1], TRUE);
  #endif
-   default:
+     default:
-   return FALSE;
+     return FALSE;
+     }
    }
  /* 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
-Line 3217 
 switch(op_code)
+Line 3257 
 switch(op_code)
    {
    case OP_CHAR:
    case OP_CHARI:
- #ifdef SUPPORT_UTF
-   GETCHARTEST(c, previous);
- #else
-   c = *previous;
- #endif
    switch(-next)
      {
      case ESC_d:
-Line 3246 
 switch(op_code)
+Line 3281 
 switch(op_code)
      case ESC_H:
      switch(c)
        {
-       case 0x09:
+       HSPACE_CASES:
-       case 0x20:
-       case 0xa0:
-       case 0x1680:
-       case 0x180e:
-       case 0x2000:
-       case 0x2001:
-       case 0x2002:
-       case 0x2003:
-       case 0x2004:
-       case 0x2005:
-       case 0x2006:
-       case 0x2007:
-       case 0x2008:
-       case 0x2009:
-       case 0x200A:
-       case 0x202f:
-       case 0x205f:
-       case 0x3000:
        return -next != ESC_h;
        default:
        return -next == ESC_h;
        }
-Line 3274 
 switch(op_code)
+Line 3292 
 switch(op_code)
      case ESC_V:
      switch(c)
        {
-       case 0x0a:
+       VSPACE_CASES:
-       case 0x0b:
-       case 0x0c:
-       case 0x0d:
-       case 0x85:
-       case 0x2028:
-       case 0x2029:
        return -next != ESC_v;
        default:
        return -next == ESC_v;
        }
-Line 3386 
 switch(op_code)
+Line 3399 
 switch(op_code)
  /*************************************************
+ *        Add a character or range to a class     *
+ *************************************************/
+ /* This function packages up the logic of adding a character or range of
+ characters to a class. The character values in the arguments will be within the
+ valid values for the current mode (8-bit, 16-bit, UTF, etc). This function is
+ mutually recursive with the function immediately below.
+ Arguments:
+   classbits     the bit map for characters < 256
+   uchardptr     points to the pointer for extra data
+   options       the options word
+   cd            contains pointers to tables etc.
+   start         start of range character
+   end           end of range character
+ Returns:        the number of < 256 characters added
+                 the pointer to extra data is updated
+ */
+ static int
+ add_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,
+   compile_data *cd, unsigned int start, unsigned int end)
+ {
+ unsigned int c;
+ int n8 = 0;
+ /* If caseless matching is required, scan the range and process alternate
+ cases. In Unicode, there are 8-bit characters that have alternate cases that
+ are greater than 255 and vice-versa. Sometimes we can just extend the original
+ range. */
+ if ((options & PCRE_CASELESS) != 0)
+   {
+ #ifdef SUPPORT_UCP
+   if ((options & PCRE_UTF8) != 0)
+     {
+     int rc;
+     unsigned int oc, od;
+     options &= ~PCRE_CASELESS;   /* Remove for recursive calls */
+     c = start;
+     while ((rc = get_othercase_range(&c, end, &oc, &od)) >= 0)
+       {
+       /* Handle a single character that has more than one other case. */
+       if (rc > 0) n8 += add_list_to_class(classbits, uchardptr, options, cd,
+         PRIV(ucd_caseless_sets) + rc, oc);
+       /* Do nothing if the other case range is within the original range. */
+       else if (oc >= start && od <= end) continue;
+       /* Extend the original range if there is overlap, noting that if oc < c, we
+       can't have od > end because a subrange is always shorter than the basic
+       range. Otherwise, use a recursive call to add the additional range. */
+       else if (oc < start && od >= start - 1) start = oc; /* Extend downwards */
+       else if (od > end && oc <= end + 1) end = od;       /* Extend upwards */
+       else n8 += add_to_class(classbits, uchardptr, options, cd, oc, od);
+       }
+     }
+   else
+ #endif  /* SUPPORT_UCP */
+   /* Not UTF-mode, or no UCP */
+   for (c = start; c <= end && c < 256; c++)
+     {
+     SETBIT(classbits, cd->fcc[c]);
+     n8++;
+     }
+   }
+ /* Now handle the original range. Adjust the final value according to the bit
+ length - this means that the same lists of (e.g.) horizontal spaces can be used
+ in all cases. */
+ #if defined COMPILE_PCRE8
+ #ifdef SUPPORT_UTF
+   if ((options & PCRE_UTF8) == 0)
+ #endif
+   if (end > 0xff) end = 0xff;
+ #elif defined COMPILE_PCRE16
+ #ifdef SUPPORT_UTF
+   if ((options & PCRE_UTF16) == 0)
+ #endif
+   if (end > 0xffff) end = 0xffff;
+ #elif defined COMPILE_PCRE32
+ #ifdef SUPPORT_UTF
+   if ((options & PCRE_UTF32) == 0)
+     if (end > 0xffffu) end = 0xffffu; // FIXMEchpe rebase fix this
+ #endif
+ #endif /* COMPILE_PCRE[8|16|32] */
+ /* If all characters are less than 256, use the bit map. Otherwise use extra
+ data. */
+ if (end < 0x100)
+   {
+   for (c = start; c <= end; c++)
+     {
+     n8++;
+     SETBIT(classbits, c);
+     }
+   }
+ else
+   {
+   pcre_uchar *uchardata = *uchardptr;
+ #ifdef SUPPORT_UTF
+   if ((options & PCRE_UTF8) != 0)  /* All UTFs use the same flag bit */
+     {
+     if (start < end)
+       {
+       *uchardata++ = XCL_RANGE;
+       uchardata += PRIV(ord2utf)(start, uchardata);
+       uchardata += PRIV(ord2utf)(end, uchardata);
+       }
+     else if (start == end)
+       {
+       *uchardata++ = XCL_SINGLE;
+       uchardata += PRIV(ord2utf)(start, uchardata);
+       }
+     }
+   else
+ #endif  /* SUPPORT_UTF */
+   /* Without UTF support, character values are constrained by the bit length,
+   and can only be > 256 for 16-bit and 32-bit libraries. */
+ #ifdef COMPILE_PCRE8
+     {}
+ #else
+   if (start < end)
+     {
+     *uchardata++ = XCL_RANGE;
+     *uchardata++ = start;
+     *uchardata++ = end;
+     }
+   else if (start == end)
+     {
+     *uchardata++ = XCL_SINGLE;
+     *uchardata++ = start;
+     }
+ #endif
+   *uchardptr = uchardata;   /* Updata extra data pointer */
+   }
+ return n8;    /* Number of 8-bit characters */
+ }
+ /*************************************************
+ *        Add a list of characters to a class     *
+ *************************************************/
+ /* This function is used for adding a list of case-equivalent characters to a
+ class, and also for adding a list of horizontal or vertical whitespace. If the
+ list is in order (which it should be), ranges of characters are detected and
+ handled appropriately. This function is mutually recursive with the function
+ above.
+ Arguments:
+   classbits     the bit map for characters < 256
+   uchardptr     points to the pointer for extra data
+   options       the options word
+   cd            contains pointers to tables etc.
+   p             points to row of 32-bit values, terminated by NOTACHAR
+   except        character to omit; this is used when adding lists of
+                   case-equivalent characters to avoid including the one we
+                   already know about
+ Returns:        the number of < 256 characters added
+                 the pointer to extra data is updated
+ */
+ static int
+ add_list_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,
+   compile_data *cd, const pcre_uint32 *p, unsigned int except)
+ {
+ int n8 = 0;
+ while (p[0] < NOTACHAR)
+   {
+   int n = 0;
+   if (p[0] != except)
+     {
+     while(p[n+1] == p[0] + n + 1) n++;
+     n8 += add_to_class(classbits, uchardptr, options, cd, p[0], p[n]);
+     }
+   p += n + 1;
+   }
+ return n8;
+ }
+ /*************************************************
+ *    Add characters not in a list to a class     *
+ *************************************************/
+ /* This function is used for adding the complement of a list of horizontal or
+ vertical whitespace to a class. The list must be in order.
+ Arguments:
+   classbits     the bit map for characters < 256
+   uchardptr     points to the pointer for extra data
+   options       the options word
+   cd            contains pointers to tables etc.
+   p             points to row of 32-bit values, terminated by NOTACHAR
+ Returns:        the number of < 256 characters added
+                 the pointer to extra data is updated
+ */
+ static int
+ add_not_list_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr,
+   int options, compile_data *cd, const pcre_uint32 *p)
+ {
+ int n8 = 0;
+ if (p[0] > 0)
+   n8 += add_to_class(classbits, uchardptr, options, cd, 0, p[0] - 1);
+ while (p[0] < NOTACHAR)
+   {
+   while (p[1] == p[0] + 1) p++;
+   n8 += add_to_class(classbits, uchardptr, options, cd, p[0] + 1,
+     (p[1] == NOTACHAR)? 0x10ffff : p[1] - 1);
+   p++;
+   }
+ return n8;
+ }
+ /*************************************************
  *           Compile one branch                   *
  *************************************************/
-Line 3448 
 must not do this for other options (e.g.
+Line 3703 
 must not do this for other options (e.g.
  dynamically as we process the pattern. */
  #ifdef SUPPORT_UTF
- /* PCRE_UTF16 has the same value as PCRE_UTF8. */
+ /* PCRE_UTF(16|32) have the same value as PCRE_UTF8. */
  BOOL utf = (options & PCRE_UTF8) != 0;
  pcre_uchar utf_chars[6];
  #else
  BOOL utf = FALSE;
  #endif
- /* Helper variables for OP_XCLASS opcode (for characters > 255). */
+ /* Helper variables for OP_XCLASS opcode (for characters > 255). We define
+ class_uchardata always so that it can be passed to add_to_class() always,
+ though it will not be used in non-UTF 8-bit cases. This avoids having to supply
+ alternative calls for the different cases. */
+ pcre_uchar *class_uchardata;
  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
  BOOL xclass;
- pcre_uchar *class_uchardata;
  pcre_uchar *class_uchardata_base;
  #endif
-Line 3503 
 for (;; ptr++)
+Line 3761 
 for (;; ptr++)
    BOOL is_recurse;
    BOOL reset_bracount;
    int class_has_8bitchar;
-   int class_single_char;
+   int class_one_char;
    int newoptions;
    int recno;
    int refsign;
-Line 3801 
 for (;; ptr++)
+Line 4059 
 for (;; ptr++)
      should_flip_negation = FALSE;
-     /* For optimization purposes, we track some properties of the class.
+     /* For optimization purposes, we track some properties of the class:
-     class_has_8bitchar will be non-zero, if the class contains at least one
+     class_has_8bitchar will be non-zero if the class contains at least one <
-     < 256 character. class_single_char will be 1 if the class contains only
+character; class_one_char will be 1 if the class contains just one
-     a single character. */
+     character. */
      class_has_8bitchar = 0;
-     class_single_char = 0;
+     class_one_char = 0;
      /* Initialize the 32-char bit map to all zeros. We build the map in a
-     temporary bit of memory, in case the class contains only 1 character (less
+     temporary bit of memory, in case the class contains fewer than two
-     than 256), because in that case the compiled code doesn't use the bit map.
+-bit characters because in that case the compiled code doesn't use the bit
-     */
+     map. */
      memset(classbits, 0, 32 * sizeof(pcre_uint8));
  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
-     xclass = FALSE;                           /* No chars >= 256 */
+     xclass = FALSE;
-     class_uchardata = code + LINK_SIZE + 2;   /* For UTF-8 items */
+     class_uchardata = code + LINK_SIZE + 2;   /* For XCLASS items */
-     class_uchardata_base = class_uchardata;   /* For resetting in pass 1 */
+     class_uchardata_base = class_uchardata;   /* Save the start */
  #endif
      /* Process characters until ] is reached. By writing this as a "do" it
-Line 3830 
 for (;; ptr++)
+Line 4088 
 for (;; ptr++)
        {
        const pcre_uchar *oldptr;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
        if (utf && HAS_EXTRALEN(c))
          {                           /* Braces are required because the */
          GETCHARLEN(c, ptr, ptr);    /* macro generates multiple statements */
-Line 3841 
 for (;; ptr++)
+Line 4099 
 for (;; ptr++)
        /* In the pre-compile phase, accumulate the length of any extra
        data and reset the pointer. This is so that very large classes that
        contain a zillion > 255 characters no longer overwrite the work space
-       (which is on the stack). */
+       (which is on the stack). We have to remember that there was XCLASS data,
+       however. */
-       if (lengthptr != NULL)
+       if (lengthptr != NULL && class_uchardata > class_uchardata_base)
          {
+         xclass = TRUE;
          *lengthptr += class_uchardata - class_uchardata_base;
          class_uchardata = class_uchardata_base;
          }
-Line 3903 
 for (;; ptr++)
+Line 4163 
 for (;; ptr++)
          alpha. This relies on the fact that the class table starts with
          alpha, lower, upper as the first 3 entries. */
          if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
            posix_class = 0;
          /* When PCRE_UCP is set, some of the POSIX classes are converted to
-Line 3946 
 for (;; ptr++)
+Line 4206 
 for (;; ptr++)
              for (c = 0; c < 32; c++) pbits[c] &= ~cbits[c + taboffset];
            }
-         /* Not see if we need to remove any special characters. An option
+         /* Now see if we need to remove any special characters. An option
          value of 1 removes vertical space and 2 removes underscore. */
          if (tabopt < 0) tabopt = -tabopt;
-Line 3962 
 for (;; ptr++)
+Line 4222 
 for (;; ptr++)
            for (c = 0; c < 32; c++) classbits[c] |= pbits[c];
          ptr = tempptr + 1;
-         /* Every class contains at least one < 256 characters. */
+         /* Every class contains at least one < 256 character. */
          class_has_8bitchar = 1;
          /* Every class contains at least two characters. */
-         class_single_char = 2;
+         class_one_char = 2;
          continue;    /* End of POSIX syntax handling */
          }
-Line 3973 
 for (;; ptr++)
+Line 4233 
 for (;; ptr++)
        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. We
        assume that other escapes have more than one character in them, so
-       speculatively set both class_has_8bitchar and class_single_char bigger
+       speculatively set both class_has_8bitchar and class_one_char bigger
        than one. Unrecognized escapes fall through and are either treated
        as literal characters (by default), or are faulted if
        PCRE_EXTRA is set. */
-Line 4006 
 for (;; ptr++)
+Line 4266 
 for (;; ptr++)
            /* Every class contains at least two < 256 characters. */
            class_has_8bitchar++;
            /* Every class contains at least two characters. */
-           class_single_char += 2;
+           class_one_char += 2;
            switch (-c)
              {
-Line 4042 
 for (;; ptr++)
+Line 4302 
 for (;; ptr++)
              /* 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. */
+             class. Luckily, the value of CHAR_VT is 0x0b in both ASCII and
+             EBCDIC, so we lazily just adjust the appropriate bit. */
              case ESC_s:
              classbits[0] |= cbits[cbit_space];
-Line 4055 
 for (;; ptr++)
+Line 4316 
 for (;; ptr++)
              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
              classbits[1] |= 0x08;    /* Perl 5.004 onwards omits VT from \s */
              continue;
+             /* The rest apply in both UCP and non-UCP cases. */
              case ESC_h:
-             SETBIT(classbits, 0x09); /* VT */
+             (void)add_list_to_class(classbits, &class_uchardata, options, cd,
-             SETBIT(classbits, 0x20); /* SPACE */
+               PRIV(hspace_list), NOTACHAR);
-             SETBIT(classbits, 0xa0); /* NSBP */
- #ifndef COMPILE_PCRE8
-             xclass = TRUE;
-             *class_uchardata++ = XCL_SINGLE;
-             *class_uchardata++ = 0x1680;
-             *class_uchardata++ = XCL_SINGLE;
-             *class_uchardata++ = 0x180e;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x2000;
-             *class_uchardata++ = 0x200a;
-             *class_uchardata++ = XCL_SINGLE;
-             *class_uchardata++ = 0x202f;
-             *class_uchardata++ = XCL_SINGLE;
-             *class_uchardata++ = 0x205f;
-             *class_uchardata++ = XCL_SINGLE;
-             *class_uchardata++ = 0x3000;
- #elif defined SUPPORT_UTF
-             if (utf)
-               {
-               xclass = TRUE;
-               *class_uchardata++ = XCL_SINGLE;
-               class_uchardata += PRIV(ord2utf)(0x1680, class_uchardata);
-               *class_uchardata++ = XCL_SINGLE;
-               class_uchardata += PRIV(ord2utf)(0x180e, class_uchardata);
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x2000, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x200a, class_uchardata);
-               *class_uchardata++ = XCL_SINGLE;
-               class_uchardata += PRIV(ord2utf)(0x202f, class_uchardata);
-               *class_uchardata++ = XCL_SINGLE;
-               class_uchardata += PRIV(ord2utf)(0x205f, class_uchardata);
-               *class_uchardata++ = XCL_SINGLE;
-               class_uchardata += PRIV(ord2utf)(0x3000, class_uchardata);
-               }
- #endif
              continue;
              case ESC_H:
-             for (c = 0; c < 32; c++)
+             (void)add_not_list_to_class(classbits, &class_uchardata, options,
-               {
+               cd, PRIV(hspace_list));
-               int x = 0xff;
-               switch (c)
-                 {
-                 case 0x09/8: x ^= 1 << (0x09%8); break;
-                 case 0x20/8: x ^= 1 << (0x20%8); break;
-                 case 0xa0/8: x ^= 1 << (0xa0%8); break;
-                 default: break;
-                 }
-               classbits[c] |= x;
-               }
- #ifndef COMPILE_PCRE8
-             xclass = TRUE;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x0100;
-             *class_uchardata++ = 0x167f;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x1681;
-             *class_uchardata++ = 0x180d;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x180f;
-             *class_uchardata++ = 0x1fff;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x200b;
-             *class_uchardata++ = 0x202e;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x2030;
-             *class_uchardata++ = 0x205e;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x2060;
-             *class_uchardata++ = 0x2fff;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x3001;
- #ifdef SUPPORT_UTF
-             if (utf)
-               class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);
-             else
- #endif
-               *class_uchardata++ = 0xffff;
- #elif defined SUPPORT_UTF
-             if (utf)
-               {
-               xclass = TRUE;
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x0100, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x167f, class_uchardata);
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x1681, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x180d, class_uchardata);
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x180f, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x1fff, class_uchardata);
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x200b, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x202e, class_uchardata);
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x2030, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x205e, class_uchardata);
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x2060, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x2fff, class_uchardata);
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x3001, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);
-               }
- #endif
              continue;
              case ESC_v:
-             SETBIT(classbits, 0x0a); /* LF */
+             (void)add_list_to_class(classbits, &class_uchardata, options, cd,
-             SETBIT(classbits, 0x0b); /* VT */
+               PRIV(vspace_list), NOTACHAR);
-             SETBIT(classbits, 0x0c); /* FF */
-             SETBIT(classbits, 0x0d); /* CR */
-             SETBIT(classbits, 0x85); /* NEL */
- #ifndef COMPILE_PCRE8
-             xclass = TRUE;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x2028;
-             *class_uchardata++ = 0x2029;
- #elif defined SUPPORT_UTF
-             if (utf)
-               {
-               xclass = TRUE;
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x2028, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x2029, class_uchardata);
-               }
- #endif
              continue;
              case ESC_V:
-             for (c = 0; c < 32; c++)
+             (void)add_not_list_to_class(classbits, &class_uchardata, options,
-               {
+               cd, PRIV(vspace_list));
-               int x = 0xff;
-               switch (c)
-                 {
-                 case 0x0a/8: x ^= 1 << (0x0a%8);
-                              x ^= 1 << (0x0b%8);
-                              x ^= 1 << (0x0c%8);
-                              x ^= 1 << (0x0d%8);
-                              break;
-                 case 0x85/8: x ^= 1 << (0x85%8); break;
-                 default: break;
-                 }
-               classbits[c] |= x;
-               }
- #ifndef COMPILE_PCRE8
-             xclass = TRUE;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x0100;
-             *class_uchardata++ = 0x2027;
-             *class_uchardata++ = XCL_RANGE;
-             *class_uchardata++ = 0x202a;
- #ifdef SUPPORT_UTF
-             if (utf)
-               class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);
-             else
- #endif
-               *class_uchardata++ = 0xffff;
- #elif defined SUPPORT_UTF
-             if (utf)
-               {
-               xclass = TRUE;
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x0100, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x2027, class_uchardata);
-               *class_uchardata++ = XCL_RANGE;
-               class_uchardata += PRIV(ord2utf)(0x202a, class_uchardata);
-               class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);
-               }
- #endif
              continue;
  #ifdef SUPPORT_UCP
-Line 4240 
 for (;; ptr++)
+Line 4347 
 for (;; ptr++)
                int pdata;
                int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
                if (ptype < 0) goto FAILED;
-               xclass = TRUE;
                *class_uchardata++ = ((-c == ESC_p) != negated)?
                  XCL_PROP : XCL_NOTPROP;
                *class_uchardata++ = ptype;
-Line 4260 
 for (;; ptr++)
+Line 4366 
 for (;; ptr++)
                goto FAILED;
                }
              class_has_8bitchar--;    /* Undo the speculative increase. */
-             class_single_char -= 2;  /* Undo the speculative increase. */
+             class_one_char -= 2;     /* Undo the speculative increase. */
              c = *ptr;                /* Get the final character and fall through */
              break;
              }
            }
-         /* Fall through if we have a single character (c >= 0). This may be
+         /* Fall through if the escape just defined a single character (c >= 0).
-         greater than 256. */
+         This may be greater than 256. */
          }   /* End of backslash handling */
-       /* A single character may be followed by '-' to form a range. However,
+       /* A character may be followed by '-' to form a range. However, Perl does
-       Perl does not permit ']' to be the end of the range. A '-' character
+       not permit ']' to be the end of the range. A '-' character at the end is
-       at the end is treated as a literal. Perl ignores orphaned \E sequences
+       treated as a literal. Perl ignores orphaned \E sequences entirely. The
-       entirely. The code for handling \Q and \E is messy. */
+       code for handling \Q and \E is messy. */
        CHECK_RANGE:
        while (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
-Line 4282 
 for (;; ptr++)
+Line 4388 
 for (;; ptr++)
          inescq = FALSE;
          ptr += 2;
          }
        oldptr = ptr;
-       /* Remember \r or \n */
+       /* Remember if \r or \n were explicitly used */
        if (c == CHAR_CR || c == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;
-Line 4308 
 for (;; ptr++)
+Line 4413 
 for (;; ptr++)
            inescq = TRUE;
            break;
            }
+         /* Minus (hyphen) at the end of a class is treated as a literal, so put
+         back the pointer and jump to handle the character that preceded it. */
          if (*ptr == 0 || (!inescq && *ptr == CHAR_RIGHT_SQUARE_BRACKET))
            {
            ptr = oldptr;
-           goto LONE_SINGLE_CHARACTER;
+           goto CLASS_SINGLE_CHARACTER;
            }
+         /* Otherwise, we have a potential range; pick up the next character */
  #ifdef SUPPORT_UTF
          if (utf)
-Line 4333 
 for (;; ptr++)
+Line 4443 
 for (;; ptr++)
            d = check_escape(&ptr, errorcodeptr, cd->bracount, options, TRUE);
            if (*errorcodeptr != 0) goto FAILED;
-           /* \b is backspace; any other special means the '-' was literal */
+           /* \b is backspace; any other special means the '-' was literal. */
            if (d < 0)
              {
              if (d == -ESC_b) d = CHAR_BS; else
                {
                ptr = oldptr;
-               goto LONE_SINGLE_CHARACTER;  /* A few lines below */
+               goto CLASS_SINGLE_CHARACTER;  /* A few lines below */
                }
              }
            }
          /* Check that the two values are in the correct order. Optimize
-         one-character ranges */
+         one-character ranges. */
          if (d < c)
            {
            *errorcodeptr = ERR8;
            goto FAILED;
            }
+         if (d == c) goto CLASS_SINGLE_CHARACTER;  /* A few lines below */
-         if (d == c) goto LONE_SINGLE_CHARACTER;  /* A few lines below */
+         /* We have found a character range, so single character optimizations
+         cannot be done anymore. Any value greater than 1 indicates that there
+         is more than one character. */
+         class_one_char = 2;
-         /* Remember \r or \n */
+         /* Remember an explicit \r or \n, and add the range to the class. */
          if (d == CHAR_CR || d == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;
-         /* Since we found a character range, single character optimizations
+         class_has_8bitchar +=
-         cannot be done anymore. */
+           add_to_class(classbits, &class_uchardata, options, cd, c, d);
-         class_single_char = 2;
-         /* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless
-         matching, we have to use an XCLASS with extra data items. Caseless
-         matching for characters > 127 is available only if UCP support is
-         available. */
- #if defined SUPPORT_UTF && !(defined COMPILE_PCRE8)
-         if ((d > 255) || (utf && ((options & PCRE_CASELESS) != 0 && d > 127)))
- #elif defined  SUPPORT_UTF
-         if (utf && (d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127)))
- #elif !(defined COMPILE_PCRE8)
-         if (d > 255)
- #endif
- #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
-           {
-           xclass = TRUE;
-           /* With UCP support, we can find the other case equivalents of
-           the relevant characters. There may be several ranges. Optimize how
-           they fit with the basic range. */
- #ifdef SUPPORT_UCP
- #ifndef COMPILE_PCRE8
-           if (utf && (options & PCRE_CASELESS) != 0)
- #else
-           if ((options & PCRE_CASELESS) != 0)
- #endif
-             {
-             unsigned int occ, ocd;
-             unsigned int cc = c;
-             unsigned int origd = d;
-             while (get_othercase_range(&cc, origd, &occ, &ocd))
-               {
-               if (occ >= (unsigned int)c &&
-                   ocd <= (unsigned int)d)
-                 continue;                          /* Skip embedded ranges */
-               if (occ < (unsigned int)c  &&
-                   ocd >= (unsigned int)c - 1)      /* Extend the basic range */
-                 {                                  /* if there is overlap,   */
-                 c = occ;                           /* noting that if occ < c */
-                 continue;                          /* we can't have ocd > d  */
-                 }                                  /* because a subrange is  */
-               if (ocd > (unsigned int)d &&
-                   occ <= (unsigned int)d + 1)      /* always shorter than    */
-                 {                                  /* the basic range.       */
-                 d = ocd;
-                 continue;
-                 }
-               if (occ == ocd)
-                 {
-                 *class_uchardata++ = XCL_SINGLE;
-                 }
-               else
-                 {
-                 *class_uchardata++ = XCL_RANGE;
-                 class_uchardata += PRIV(ord2utf)(occ, class_uchardata);
-                 }
-               class_uchardata += PRIV(ord2utf)(ocd, class_uchardata);
-               }
-             }
- #endif  /* SUPPORT_UCP */
-           /* Now record the original range, possibly modified for UCP caseless
-           overlapping ranges. */
-           *class_uchardata++ = XCL_RANGE;
- #ifdef SUPPORT_UTF
- #ifndef COMPILE_PCRE8
-           if (utf)
-             {
-             class_uchardata += PRIV(ord2utf)(c, class_uchardata);
-             class_uchardata += PRIV(ord2utf)(d, class_uchardata);
-             }
-           else
-             {
-             *class_uchardata++ = c;
-             *class_uchardata++ = d;
-             }
- #else
-           class_uchardata += PRIV(ord2utf)(c, class_uchardata);
-           class_uchardata += PRIV(ord2utf)(d, class_uchardata);
- #endif
- #else /* SUPPORT_UTF */
-           *class_uchardata++ = c;
-           *class_uchardata++ = d;
- #endif /* SUPPORT_UTF */
-           /* With UCP support, we are done. Without UCP support, there is no
-           caseless matching for UTF characters > 127; we can use the bit map
-           for the smaller ones. As for 16 bit characters without UTF, we
-           can still use  */
- #ifdef SUPPORT_UCP
- #ifndef COMPILE_PCRE8
-           if (utf)
- #endif
-             continue;    /* With next character in the class */
- #endif  /* SUPPORT_UCP */
- #if defined SUPPORT_UTF && !defined(SUPPORT_UCP) && !(defined COMPILE_PCRE8)
-           if (utf)
-             {
-             if ((options & PCRE_CASELESS) == 0 || c > 127) continue;
-             /* Adjust upper limit and fall through to set up the map */
-             d = 127;
-             }
-           else
-             {
-             if (c > 255) continue;
-             /* Adjust upper limit and fall through to set up the map */
-             d = 255;
-             }
- #elif defined SUPPORT_UTF && !defined(SUPPORT_UCP)
-           if ((options & PCRE_CASELESS) == 0 || c > 127) continue;
-           /* Adjust upper limit and fall through to set up the map */
-           d = 127;
- #else
-           if (c > 255) continue;
-           /* Adjust upper limit and fall through to set up the map */
-           d = 255;
- #endif  /* SUPPORT_UTF && !SUPPORT_UCP && !COMPILE_PCRE8 */
-           }
- #endif  /* SUPPORT_UTF || !COMPILE_PCRE8 */
-         /* We use the bit map for 8 bit mode, or when the characters fall
-         partially or entirely to [0-255] ([0-127] for UCP) ranges. */
-         class_has_8bitchar = 1;
-         /* We can save a bit of time by skipping this in the pre-compile. */
-         if (lengthptr == NULL) for (; c <= d; c++)
-           {
-           classbits[c/8] |= (1 << (c&7));
-           if ((options & PCRE_CASELESS) != 0)
-             {
-             int uc = cd->fcc[c]; /* flip case */
-             classbits[uc/8] |= (1 << (uc&7));
-             }
-           }
          continue;   /* Go get the next char in the class */
          }
-       /* Handle a lone single character - we can get here for a normal
+       /* Handle a single character - we can get here for a normal non-escape
-       non-escape char, or after \ that introduces a single character or for an
+       char, or after \ that introduces a single character or for an apparent
-       apparent range that isn't. */
+       range that isn't. Only the value 1 matters for class_one_char, so don't
+       increase it if it is already 2 or more ... just in case there's a class
-       LONE_SINGLE_CHARACTER:
+       with a zillion characters in it. */
-       /* Only the value of 1 matters for class_single_char. */
+       CLASS_SINGLE_CHARACTER:
+       if (class_one_char < 2) class_one_char++;
-       if (class_single_char < 2) class_single_char++;
+       /* If class_one_char is 1, we have the first single character in the
-       /* If class_charcount is 1, we saw precisely one character. As long as
+       class, and there have been no prior ranges, or XCLASS items generated by
-       there was no use of \p or \P, in other words, no use of any XCLASS
+       escapes. If this is the final character in the class, we can optimize by
-       features, we can optimize.
+       turning the item into a 1-character OP_CHAR[I] if it's positive, or
+       OP_NOT[I] if it's negative. In the positive case, it can cause firstchar
-       The optimization throws away the bit map. We turn the item into a
+       to be set. Otherwise, there can be no first char if this item is first,
--character OP_CHAR[I] if it's positive, or OP_NOT[I] if it's negative.
+       whatever repeat count may follow. In the case of reqchar, save the
-       In the positive case, it can cause firstchar to be set. Otherwise, there
+       previous value for reinstating. */
-       can be no first char if this item is first, whatever repeat count may
-       follow. In the case of reqchar, save the previous value for reinstating. */
-       if (class_single_char == 1 && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
+       if (class_one_char == 1 && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
          {
          ptr++;
          zeroreqchar = reqchar;
          if (negate_class)
            {
+ #ifdef SUPPORT_UCP
+             // FIXMEchpe pcreuint32?
+           int d;
+ #endif
            if (firstchar == REQ_UNSET) firstchar = REQ_NONE;
            zerofirstchar = firstchar;
-           *code++ = ((options & PCRE_CASELESS) != 0)? OP_NOTI: OP_NOT;
- #ifdef SUPPORT_UTF
+           /* For caseless UTF-8 mode when UCP support is available, check
-           if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)
+           whether this character has more than one other case. If so, generate
-             code += PRIV(ord2utf)(c, code);
+           a special OP_NOTPROP item instead of OP_NOTI. */
-           else
+ #ifdef SUPPORT_UCP
+           if (utf && (options & PCRE_CASELESS) != 0 &&
+               (d = UCD_CASESET(c)) != 0)
+             {
+             *code++ = OP_NOTPROP;
+             *code++ = PT_CLIST;
+             *code++ = d;
+             }
+           else
  #endif
-             *code++ = c;
+           /* Char has only one other case, or UCP not available */
-           goto NOT_CHAR;
+             {
+             *code++ = ((options & PCRE_CASELESS) != 0)? OP_NOTI: OP_NOT;
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+             if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)
+               code += PRIV(ord2utf)(c, code);
+             else
+ #endif
+               *code++ = c;
+             }
+           /* We are finished with this character class */
+           goto END_CLASS;
            }
          /* For a single, positive character, get the value into mcbuffer, and
          then we can handle this with the normal one-character code. */
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
          if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)
            mclength = PRIV(ord2utf)(c, mcbuffer);
          else
-Line 4562 
 for (;; ptr++)
+Line 4558 
 for (;; ptr++)
            }
          goto ONE_CHAR;
          }       /* End of 1-char optimization */
-       /* Handle a character that cannot go in the bit map. */
+       /* There is more than one character in the class, or an XCLASS item
+       has been generated. Add this character to the class. */
- #if defined SUPPORT_UTF && !(defined COMPILE_PCRE8)
-       if ((c > 255) || (utf && ((options & PCRE_CASELESS) != 0 && c > 127)))
+       class_has_8bitchar +=
- #elif defined SUPPORT_UTF
+         add_to_class(classbits, &class_uchardata, options, cd, c, c);
-       if (utf && (c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127)))
- #elif !(defined COMPILE_PCRE8)
-       if (c > 255)
- #endif
- #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
-         {
-         xclass = TRUE;
-         *class_uchardata++ = XCL_SINGLE;
- #ifdef SUPPORT_UTF
- #ifndef COMPILE_PCRE8
-         /* In non 8 bit mode, we can get here even if we are not in UTF mode. */
-         if (!utf)
-           *class_uchardata++ = c;
-         else
- #endif
-           class_uchardata += PRIV(ord2utf)(c, class_uchardata);
- #else /* SUPPORT_UTF */
-         *class_uchardata++ = c;
- #endif /* SUPPORT_UTF */
- #ifdef SUPPORT_UCP
- #ifdef COMPILE_PCRE8
-         if ((options & PCRE_CASELESS) != 0)
- #else
-         /* In non 8 bit mode, we can get here even if we are not in UTF mode. */
-         if (utf && (options & PCRE_CASELESS) != 0)
- #endif
-           {
-           unsigned int othercase;
-           if ((int)(othercase = UCD_OTHERCASE(c)) != c)
-             {
-             *class_uchardata++ = XCL_SINGLE;
-             class_uchardata += PRIV(ord2utf)(othercase, class_uchardata);
-             }
-           }
- #endif  /* SUPPORT_UCP */
-         }
-       else
- #endif  /* SUPPORT_UTF || COMPILE_PCRE16 */
-       /* Handle a single-byte character */
-         {
-         class_has_8bitchar = 1;
-         classbits[c/8] |= (1 << (c&7));
-         if ((options & PCRE_CASELESS) != 0)
-           {
-           c = cd->fcc[c]; /* flip case */
-           classbits[c/8] |= (1 << (c&7));
-           }
-         }
        }
      /* Loop until ']' reached. This "while" is the end of the "do" far above.
-Line 4639 
 for (;; ptr++)
+Line 4583 
 for (;; ptr++)
        goto FAILED;
        }
+     /* We will need an XCLASS if data has been placed in class_uchardata. In
+     the second phase this is a sufficient test. However, in the pre-compile
+     phase, class_uchardata gets emptied to prevent workspace overflow, so it
+     only if the very last character in the class needs XCLASS will it contain
+     anything at this point. For this reason, xclass gets set TRUE above when
+     uchar_classdata is emptied, and that's why this code is the way it is here
+     instead of just doing a test on class_uchardata below. */
+ #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+     if (class_uchardata > class_uchardata_base) xclass = TRUE;
+ #endif
      /* If this is the first thing in the branch, there can be no first char
      setting, whatever the repeat count. Any reqchar setting must remain
      unchanged after any kind of repeat. */
-Line 4701 
 for (;; ptr++)
+Line 4657 
 for (;; ptr++)
        memcpy(code, classbits, 32);
        }
      code += 32 / sizeof(pcre_uchar);
-     NOT_CHAR:
+     END_CLASS:
      break;
-Line 4811 
 for (;; ptr++)
+Line 4768 
 for (;; ptr++)
      if (*previous == OP_CHAR || *previous == OP_CHARI
          || *previous == OP_NOT || *previous == OP_NOTI)
        {
        switch (*previous)
          {
          default: /* Make compiler happy. */
          case OP_CHAR:  op_type = OP_STAR - OP_STAR; break;
-Line 4825 
 for (;; ptr++)
+Line 4782 
 for (;; ptr++)
        hold the length of the character in bytes, plus UTF_LENGTH to flag that
        it's a length rather than a small character. */
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
        if (utf && NOT_FIRSTCHAR(code[-1]))
          {
          pcre_uchar *lastchar = code - 1;
-Line 4961 
 for (;; ptr++)
+Line 4918 
 for (;; ptr++)
          if (repeat_max < 0)
            {
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
            if (utf && (c & UTF_LENGTH) != 0)
              {
              memcpy(code, utf_chars, IN_UCHARS(c & 7));
-Line 4986 
 for (;; ptr++)
+Line 4943 
 for (;; ptr++)
          else if (repeat_max != repeat_min)
            {
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
            if (utf && (c & UTF_LENGTH) != 0)
              {
              memcpy(code, utf_chars, IN_UCHARS(c & 7));
-Line 5016 
 for (;; ptr++)
+Line 4973 
 for (;; ptr++)
        /* The character or character type itself comes last in all cases. */
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
        if (utf && (c & UTF_LENGTH) != 0)
          {
          memcpy(code, utf_chars, IN_UCHARS(c & 7));
-Line 5503 
 for (;; ptr++)
+Line 5460 
 for (;; ptr++)
        else if (*tempcode == OP_EXACT || *tempcode == OP_NOTEXACT)
          {
          tempcode += PRIV(OP_lengths)[*tempcode];
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
          if (utf && HAS_EXTRALEN(tempcode[-1]))
            tempcode += GET_EXTRALEN(tempcode[-1]);
  #endif
-Line 5601 
 for (;; ptr++)
+Line 5558 
 for (;; ptr++)
          arg = ++ptr;
          while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
          arglen = (int)(ptr - arg);
+         if ((unsigned int)arglen > MAX_MARK)
+           {
+           *errorcodeptr = ERR75;
+           goto FAILED;
+           }
          }
        if (*ptr != CHAR_RIGHT_PARENTHESIS)
-Line 5616 
 for (;; ptr++)
+Line 5578 
 for (;; ptr++)
          if (namelen == verbs[i].len &&
              STRNCMP_UC_C8(name, vn, namelen) == 0)
            {
+           int setverb;
            /* Check for open captures before ACCEPT and convert it to
            ASSERT_ACCEPT if in an assertion. */
-Line 5633 
 for (;; ptr++)
+Line 5597 
 for (;; ptr++)
                *code++ = OP_CLOSE;
                PUT2INC(code, 0, oc->number);
                }
-             *code++ = (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;
+             setverb = *code++ =
+               (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;
              /* Do not set firstchar after *ACCEPT */
              if (firstchar == REQ_UNSET) firstchar = REQ_NONE;
-Line 5648 
 for (;; ptr++)
+Line 5613 
 for (;; ptr++)
                *errorcodeptr = ERR66;
                goto FAILED;
                }
-             *code = verbs[i].op;
+             setverb = *code++ = verbs[i].op;
-             if (*code++ == OP_THEN) cd->external_flags |= PCRE_HASTHEN;
              }
            else
-Line 5659 
 for (;; ptr++)
+Line 5623 
 for (;; ptr++)
                *errorcodeptr = ERR59;
                goto FAILED;
                }
-             *code = verbs[i].op_arg;
+             setverb = *code++ = verbs[i].op_arg;
-             if (*code++ == OP_THEN_ARG) cd->external_flags |= PCRE_HASTHEN;
              *code++ = arglen;
              memcpy(code, arg, IN_UCHARS(arglen));
              code += arglen;
              *code++ = 0;
              }
+           switch (setverb)
+             {
+             case OP_THEN:
+             case OP_THEN_ARG:
+             cd->external_flags |= PCRE_HASTHEN;
+             break;
+             case OP_PRUNE:
+             case OP_PRUNE_ARG:
+             case OP_SKIP:
+             case OP_SKIP_ARG:
+             cd->had_pruneorskip = TRUE;
+             break;
+             }
            break;  /* Found verb, exit loop */
            }
-Line 6852 
 for (;; ptr++)
+Line 6830 
 for (;; ptr++)
        /* For the rest (including \X when Unicode properties are supported), we
        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. Note that \b and \B do a one-character
        lookbehind. */
        else
          {
          if ((-c == ESC_b || -c == ESC_B) && cd->max_lookbehind == 0)
            cd->max_lookbehind = 1;
  #ifdef SUPPORT_UCP
          if (-c >= ESC_DU && -c <= ESC_wu)
            {
-Line 6882 
 for (;; ptr++)
+Line 6860 
 for (;; ptr++)
      a value > 127. We set its representation in the length/buffer, and then
      handle it as a data character. */
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)
        mclength = PRIV(ord2utf)(c, mcbuffer);
      else
-Line 6905 
 for (;; ptr++)
+Line 6883 
 for (;; ptr++)
      mclength = 1;
      mcbuffer[0] = c;
- #ifdef SUPPORT_UTF
+ #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
      if (utf && HAS_EXTRALEN(c))
        ACROSSCHAR(TRUE, ptr[1], mcbuffer[mclength++] = *(++ptr));
  #endif
-Line 6915 
 for (;; ptr++)
+Line 6893 
 for (;; ptr++)
      ONE_CHAR:
      previous = code;
+     /* For caseless UTF-8 mode when UCP support is available, check whether
+     this character has more than one other case. If so, generate a special
+     OP_PROP item instead of OP_CHARI. */
+ #ifdef SUPPORT_UCP
+     if (utf && (options & PCRE_CASELESS) != 0)
+       {
+       GETCHAR(c, mcbuffer);
+       if ((c = UCD_CASESET(c)) != 0)
+         {
+         *code++ = OP_PROP;
+         *code++ = PT_CLIST;
+         *code++ = c;
+         if (firstchar == REQ_UNSET) firstchar = zerofirstchar = REQ_NONE;
+         break;
+         }
+       }
+ #endif
+     /* Caseful matches, or not one of the multicase characters. */
      *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARI : OP_CHAR;
      for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];
 Line 7166 
 for (;;)
          *ptrptr = ptr;
          return FALSE;
          }
        else
          {
          if (fixed_length > cd->max_lookbehind)
            cd->max_lookbehind = fixed_length;
          PUT(reverse_count, 0, fixed_length);
          }
        }
      }
 Line 7303 
 and the highest back reference was great
  However, by keeping a bitmap of the first 31 back references, we can catch some
  of the more common cases more precisely.
+ ... A second exception is when the .* appears inside an atomic group, because
+ this prevents the number of characters it matches from being adjusted.
  Arguments:
    code           points to start of expression (the bracket)
    bracket_map    a bitmap of which brackets we are inside while testing; this
                    handles up to substring 31; after that we just have to take
                    the less precise approach
-   backref_map    the back reference bitmap
+   cd             points to the compile data block
+   atomcount      atomic group level
  Returns:     TRUE or FALSE
  */
  static BOOL
  is_anchored(register const pcre_uchar *code, unsigned int bracket_map,
-   unsigned int backref_map)
+   compile_data *cd, int atomcount)
  {
  do {
     const pcre_uchar *scode = first_significant_code(
-Line 7327 
 do {
+Line 7331 
 do {
     if (op == OP_BRA  || op == OP_BRAPOS ||
         op == OP_SBRA || op == OP_SBRAPOS)
       {
-      if (!is_anchored(scode, bracket_map, backref_map)) return FALSE;
+      if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;
       }
     /* Capturing brackets */
-Line 7337 
 do {
+Line 7341 
 do {
       {
       int n = GET2(scode, 1+LINK_SIZE);
       int new_map = bracket_map | ((n < 32)? (1 << n) : 1);
-      if (!is_anchored(scode, new_map, backref_map)) return FALSE;
+      if (!is_anchored(scode, new_map, cd, atomcount)) return FALSE;
       }
-    /* Other brackets */
+    /* Positive forward assertions and conditions */
-    else if (op == OP_ASSERT || op == OP_ONCE || op == OP_ONCE_NC ||
+    else if (op == OP_ASSERT || op == OP_COND)
-             op == OP_COND)
       {
-      if (!is_anchored(scode, bracket_map, backref_map)) return FALSE;
+      if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;
+      }
+    /* Atomic groups */
+    else if (op == OP_ONCE || op == OP_ONCE_NC)
+      {
+      if (!is_anchored(scode, bracket_map, cd, atomcount + 1))
+        return FALSE;
       }
     /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and
-    it isn't in brackets that are or may be referenced. */
+    it isn't in brackets that are or may be referenced or inside an atomic
+    group. */
     else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
               op == OP_TYPEPOSSTAR))
       {
-      if (scode[1] != OP_ALLANY || (bracket_map & backref_map) != 0)
+      if (scode[1] != OP_ALLANY || (bracket_map & cd->backref_map) != 0 ||
+          atomcount > 0 || cd->had_pruneorskip)
         return FALSE;
       }
     /* Check for explicit anchoring */
     else if (op != OP_SOD && op != OP_SOM && op != OP_CIRC) return FALSE;
     code += GET(code, 1);
     }
  while (*code == OP_ALT);   /* Loop for each alternative */
-Line 7378 
 return TRUE;
+Line 7392 
 return TRUE;
  matching and for non-DOTALL patterns that start with .* (which must start at
  the beginning or after \n). As in the case of is_anchored() (see above), we
  have to take account of back references to capturing brackets that contain .*
- because in that case we can't make the assumption.
+ because in that case we can't make the assumption. Also, the appearance of .*
+ inside atomic brackets or in a pattern that contains *PRUNE or *SKIP does not
+ count, because once again the assumption no longer holds.
  Arguments:
    code           points to start of expression (the bracket)
    bracket_map    a bitmap of which brackets we are inside while testing; this
                    handles up to substring 31; after that we just have to take
                    the less precise approach
-   backref_map    the back reference bitmap
+   cd             points to the compile data
+   atomcount      atomic group level
  Returns:         TRUE or FALSE
  */
  static BOOL
  is_startline(const pcre_uchar *code, unsigned int bracket_map,
-   unsigned int backref_map)
+   compile_data *cd, int atomcount)
  {
  do {
     const pcre_uchar *scode = first_significant_code(
-Line 7418 
 do {
+Line 7435 
 do {
         return FALSE;
         default:     /* Assertion */
-        if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
+        if (!is_startline(scode, bracket_map, cd, atomcount)) return FALSE;
         do scode += GET(scode, 1); while (*scode == OP_ALT);
         scode += 1 + LINK_SIZE;
         break;
-Line 7432 
 do {
+Line 7449 
 do {
     if (op == OP_BRA  || op == OP_BRAPOS ||
         op == OP_SBRA || op == OP_SBRAPOS)
       {
-      if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
+      if (!is_startline(scode, bracket_map, cd, atomcount)) return FALSE;
       }
     /* Capturing brackets */
-Line 7442 
 do {
+Line 7459 
 do {
       {
       int n = GET2(scode, 1+LINK_SIZE);
       int new_map = bracket_map | ((n < 32)? (1 << n) : 1);
-      if (!is_startline(scode, new_map, backref_map)) return FALSE;
+      if (!is_startline(scode, new_map, cd, atomcount)) return FALSE;
       }
-    /* Other brackets */
+    /* Positive forward assertions */
-    else if (op == OP_ASSERT || op == OP_ONCE || op == OP_ONCE_NC)
+    else if (op == OP_ASSERT)
       {
-      if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
+      if (!is_startline(scode, bracket_map, cd, atomcount)) return FALSE;
       }
+    /* Atomic brackets */
-    /* .* means "start at start or after \n" if it isn't in brackets that
+    else if (op == OP_ONCE || op == OP_ONCE_NC)
-    may be referenced. */
+      {
+      if (!is_startline(scode, bracket_map, cd, atomcount + 1)) return FALSE;
+      }
+    /* .* means "start at start or after \n" if it isn't in atomic brackets or
+    brackets that may be referenced, as long as the pattern does not contain
+    *PRUNE or *SKIP, because these break the feature. Consider, for example,
+    /.*?a(*PRUNE)b/ with the subject "aab", which matches "ab", i.e. not at the
+    start of a line. */
     else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)
       {
-      if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
+      if (scode[1] != OP_ANY || (bracket_map & cd->backref_map) != 0 ||
+          atomcount > 0 || cd->had_pruneorskip)
+        return FALSE;
       }
-    /* Check for explicit circumflex */
+    /* Check for explicit circumflex; anything else gives a FALSE result. Note
+    in particular that this includes atomic brackets OP_ONCE and OP_ONCE_NC
+    because the number of characters matched by .* cannot be adjusted inside
+    them. */
     else if (op != OP_CIRC && op != OP_CIRCM) return FALSE;
-Line 7582 
 Returns:        pointer to compiled data
+Line 7614 
 Returns:        pointer to compiled data
                  with errorptr and erroroffset set
  */
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
  pcre_compile(const char *pattern, int options, const char **errorptr,
    int *erroroffset, const unsigned char *tables)
- #else
+ #elif defined COMPILE_PCRE16
  PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION
  pcre16_compile(PCRE_SPTR16 pattern, int options, const char **errorptr,
    int *erroroffset, const unsigned char *tables)
+ #elif defined COMPILE_PCRE32
+ PCRE_EXP_DEFN pcre32 * PCRE_CALL_CONVENTION
+ pcre32_compile(PCRE_SPTR32 pattern, int options, const char **errorptr,
+   int *erroroffset, const unsigned char *tables)
  #endif
  {
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
- #else
+ #elif defined COMPILE_PCRE16
  return pcre16_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
+ #elif defined COMPILE_PCRE32
+ return pcre32_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
  #endif
  }
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
  pcre_compile2(const char *pattern, int options, int *errorcodeptr,
    const char **errorptr, int *erroroffset, const unsigned char *tables)
- #else
+ #elif defined COMPILE_PCRE16
  PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION
  pcre16_compile2(PCRE_SPTR16 pattern, int options, int *errorcodeptr,
    const char **errorptr, int *erroroffset, const unsigned char *tables)
+ #elif defined COMPILE_PCRE32
+ PCRE_EXP_DEFN pcre32 * PCRE_CALL_CONVENTION
+ pcre32_compile2(PCRE_SPTR32 pattern, int options, int *errorcodeptr,
+   const char **errorptr, int *erroroffset, const unsigned char *tables)
  #endif
  {
  REAL_PCRE *re;
-Line 7693 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 7735 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
    if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 6) == 0)
      { skipatstart += 8; options |= PCRE_UTF16; continue; }
  #endif
+ #ifdef COMPILE_PCRE32
+   if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 6) == 0)
+     { skipatstart += 8; options |= PCRE_UTF32; continue; }
+ #endif
    else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UCP_RIGHTPAR, 4) == 0)
      { skipatstart += 6; options |= PCRE_UCP; continue; }
    else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_START_OPT_RIGHTPAR, 13) == 0)
-Line 7721 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 7767 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
    else break;
    }
- /* PCRE_UTF16 has the same value as PCRE_UTF8. */
+ /* PCRE_UTF(16|32) have the same value as PCRE_UTF8. */
  utf = (options & PCRE_UTF8) != 0;
  /* Can't support UTF unless PCRE has been compiled to include the code. The
-Line 7733 
 not used here. */
+Line 7779 
 not used here. */
  if (utf && (options & PCRE_NO_UTF8_CHECK) == 0 &&
       (errorcode = PRIV(valid_utf)((PCRE_PUCHAR)pattern, -1, erroroffset)) != 0)
    {
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    errorcode = ERR44;
- #else
+ #elif defined COMPILE_PCRE16
    errorcode = ERR74;
+ #elif defined COMPILE_PCRE32
+   errorcode = ERR77;
  #endif
    goto PCRE_EARLY_ERROR_RETURN2;
    }
-Line 7900 
 re->name_count = cd->names_found;
+Line 7948 
 re->name_count = cd->names_found;
  re->ref_count = 0;
  re->tables = (tables == PRIV(default_tables))? NULL : tables;
  re->nullpad = NULL;
+ #ifdef COMPILE_PCRE32
+ re->dummy1 = re->dummy2 = 0;
+ #endif
  /* The starting points of the name/number translation table and of the code are
  passed around in the compile data block. The start/end pattern and initial
-Line 7919 
 cd->start_code = codestart;
+Line 7970 
 cd->start_code = codestart;
  cd->hwm = (pcre_uchar *)(cd->start_workspace);
  cd->req_varyopt = 0;
  cd->had_accept = FALSE;
+ cd->had_pruneorskip = FALSE;
  cd->check_lookbehind = FALSE;
  cd->open_caps = NULL;
-Line 8042 
 if (errorcode != 0)
+Line 8094 
 if (errorcode != 0)
    }
  /* If the anchored option was not passed, set the flag if we can determine that
- the pattern is anchored by virtue of ^ characters or \A or anything else (such
+ the pattern is anchored by virtue of ^ characters or \A or anything else, such
- as starting with .* when DOTALL is set).
+ as starting with non-atomic .* when DOTALL is set and there are no occurrences
+ of *PRUNE or *SKIP.
  Otherwise, if we know what the first byte has to be, save it, because that
  speeds up unanchored matches no end. If not, see if we can set the
  PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
- start with ^. and also when all branches start with .* for non-DOTALL matches.
+ start with ^. and also when all branches start with non-atomic .* for
- */
+ non-DOTALL matches when *PRUNE and SKIP are not present. */
  if ((re->options & PCRE_ANCHORED) == 0)
    {
-   if (is_anchored(codestart, 0, cd->backref_map))
+   if (is_anchored(codestart, 0, cd, 0)) re->options |= PCRE_ANCHORED;
-     re->options |= PCRE_ANCHORED;
    else
      {
      if (firstchar < 0)
        firstchar = find_firstassertedchar(codestart, FALSE);
      if (firstchar >= 0)   /* Remove caseless flag for non-caseable chars */
        {
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
        re->first_char = firstchar & 0xff;
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
        re->first_char = firstchar & 0xffff;
- #endif
+ #elif defined COMPILE_PCRE32
+       re->first_char = firstchar & ~REQ_MASK;
  #endif
        if ((firstchar & REQ_CASELESS) != 0)
          {
-Line 8091 
 if ((re->options & PCRE_ANCHORED) == 0)
+Line 8143 
 if ((re->options & PCRE_ANCHORED) == 0)
        re->flags |= PCRE_FIRSTSET;
        }
-     else if (is_startline(codestart, 0, cd->backref_map))
-       re->flags |= PCRE_STARTLINE;
+     else if (is_startline(codestart, 0, cd, 0)) re->flags |= PCRE_STARTLINE;
      }
    }
-Line 8103 
 bytes. */
+Line 8155 
 bytes. */
  if (reqchar >= 0 &&
       ((re->options & PCRE_ANCHORED) == 0 || (reqchar & REQ_VARY) != 0))
    {
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
    re->req_char = reqchar & 0xff;
- #else
+ #elif defined COMPILE_PCRE16
- #ifdef COMPILE_PCRE16
    re->req_char = reqchar & 0xffff;
- #endif
+ #elif defined COMPILE_PCRE32
+   re->req_char = reqchar & ~REQ_MASK;
  #endif
    if ((reqchar & REQ_CASELESS) != 0)
      {
-Line 8160 
 if ((re->flags & PCRE_REQCHSET) != 0)
+Line 8212 
 if ((re->flags & PCRE_REQCHSET) != 0)
      else printf("Req char = \\x%02x%s\n", ch, caseless);
    }
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  pcre_printint((pcre *)re, stdout, TRUE);
- #else
+ #elif defined COMPILE_PCRE16
  pcre16_printint((pcre *)re, stdout, TRUE);
+ #elif defined COMPILE_PCRE32
+ pcre32_printint((pcre *)re, stdout, TRUE);
  #endif
  /* This check is done here in the debugging case so that the code that
-Line 8179 
 if (code - codestart > length)
+Line 8233 
 if (code - codestart > length)
    }
  #endif   /* PCRE_DEBUG */
- #ifdef COMPILE_PCRE8
+ #if defined COMPILE_PCRE8
  return (pcre *)re;
- #else
+ #elif defined COMPILE_PCRE16
  return (pcre16 *)re;
+ #elif defined COMPILE_PCRE32
+ return (pcre32 *)re;
  #endif
  }

 Legend:



Removed from v.962
 


changed lines


 
Added in v.1055
 Legend:



Removed from v.962
 


changed lines


 
Added in v.1055
-Removed from v.962
+Added in v.1055

	ViewVC Help
Powered by ViewVC 1.1.5