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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 1059 by chpe,
Tue Oct 16 15:53:53 2012 UTC
+revision 1219 by ph10,
Sun Nov 11 18:04:37 2012 UTC
 Line 84 
 static int
      const pcre_uint32 *, unsigned int);
  static BOOL
-   compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL,
+   compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL, int, int,
-     int, int, int *, int *, branch_chain *, compile_data *, int *);
+     pcre_uint32 *, pcre_int32 *, pcre_uint32 *, pcre_int32 *, branch_chain *,
+     compile_data *, int *);
-Line 121 
 overrun before it actually does run off
+Line 122 
 overrun before it actually does run off
  /* Private flags added to firstchar and reqchar. */
- #define REQ_CASELESS   0x10000000l      /* Indicates caselessness */
+ #define REQ_CASELESS    (1 << 0)        /* Indicates caselessness */
- #define REQ_VARY       0x20000000l      /* Reqchar followed non-literal item */
+ #define REQ_VARY        (1 << 1)        /* Reqchar followed non-literal item */
- #define REQ_MASK       (REQ_CASELESS | REQ_VARY)
+ /* Negative values for the firstchar and reqchar flags */
+ #define REQ_UNSET       (-2)
+ #define REQ_NONE        (-1)
  /* Repeated character flags. */
-Line 645 
 static const pcre_uint8 ebcdic_chartab[]
+Line 648 
 static const pcre_uint8 ebcdic_chartab[]
  /*************************************************
  *            Find an error text                  *
  *************************************************/
-Line 665 
 find_error_text(int n)
+Line 667 
 find_error_text(int n)
  const char *s = error_texts;
  for (; n > 0; n--)
    {
-   while (*s++ != 0) {};
+   while (*s++ != CHAR_NULL) {};
-   if (*s == 0) return "Error text not found (please report)";
+   if (*s == CHAR_NULL) return "Error text not found (please report)";
    }
  return s;
  }
-Line 750 
 return (*p == CHAR_RIGHT_CURLY_BRACKET);
+Line 752 
 return (*p == CHAR_RIGHT_CURLY_BRACKET);
  /* This function is called when a \ has been encountered. It either returns a
  positive value for a simple escape such as \n, or 0 for a data character
- which will be placed in chptr. A backreference to group
+ which will be placed in chptr. A backreference to group n is returned as
- n is returned as ESC_REF + n; ESC_REF is the highest ESC_xxx macro. When
+ negative n. When UTF-8 is enabled, a positive value greater than 255 may
- UTF-8 is enabled, a positive value greater than 255 may be returned in chptr.
+ be returned in chptr.
  On entry,ptr is pointing at the \. On exit, it is on the final character of the
  escape sequence.
-Line 766 
 Arguments:
+Line 768 
 Arguments:
  Returns:         zero => a data character
                   positive => a special escape sequence
+                  negative => a back reference
                   on error, errorcodeptr is set
  */
  static int
- check_escape(const pcre_uchar **ptrptr, int *chptr, int *errorcodeptr,
+ check_escape(const pcre_uchar **ptrptr, pcre_uint32 *chptr, int *errorcodeptr,
    int bracount, int options, BOOL isclass)
  {
  /* PCRE_UTF16 has the same value as PCRE_UTF8. */
  BOOL utf = (options & PCRE_UTF8) != 0;
  const pcre_uchar *ptr = *ptrptr + 1;
- pcre_int32 c;
+ pcre_uint32 c;
  int escape = 0;
  int i;
-Line 785 
 ptr--;                            /* Set
+Line 788 
 ptr--;                            /* Set
  /* If backslash is at the end of the pattern, it's an error. */
- if (c == 0) *errorcodeptr = ERR1;
+ if (c == CHAR_NULL) *errorcodeptr = ERR1;
  /* Non-alphanumerics are literals. For digits or letters, do an initial lookup
  in a table. A non-zero result is something that can be returned immediately.
-Line 794 
 Otherwise further processing may be requ
+Line 797 
 Otherwise further processing may be requ
  #ifndef EBCDIC  /* ASCII/UTF-8 coding */
  /* Not alphanumeric */
  else if (c < CHAR_0 || c > CHAR_z) {}
- else if ((i = escapes[c - CHAR_0]) != 0) { if (i > 0) c = i; else escape = -i; }
+ else if ((i = escapes[c - CHAR_0]) != 0) { if (i > 0) c = (pcre_uint32)i; else escape = -i; }
  #else           /* EBCDIC coding */
  /* Not alphanumeric */
  else if (c < CHAR_a || (!MAX_255(c) || (ebcdic_chartab[c] & 0x0E) == 0)) {}
- else if ((i = escapes[c - 0x48]) != 0)  { if (i > 0) c = i; else escape = -i; }
+ else if ((i = escapes[c - 0x48]) != 0)  { if (i > 0) c = (pcre_uint32)i; else escape = -i; }
  #endif
  /* Escapes that need further processing, or are illegal. */
-Line 807 
 else if ((i = escapes[c - 0x48]) != 0)
+Line 810 
 else if ((i = escapes[c - 0x48]) != 0)
  else
    {
    const pcre_uchar *oldptr;
-   BOOL braced, negated;
+   BOOL braced, negated, overflow;
+   int s;
    switch (c)
      {
-Line 832 
 else
+Line 836 
 else
          c = 0;
          for (i = 0; i < 4; ++i)
            {
-           register int cc = *(++ptr);
+           register pcre_uint32 cc = *(++ptr);
  #ifndef EBCDIC  /* ASCII/UTF-8 coding */
            if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
            c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
-Line 894 
 else
+Line 898 
 else
      if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
        {
        const pcre_uchar *p;
-       for (p = ptr+2; *p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET; p++)
+       for (p = ptr+2; *p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET; p++)
          if (*p != CHAR_MINUS && !IS_DIGIT(*p)) break;
-       if (*p != 0 && *p != CHAR_RIGHT_CURLY_BRACKET)
+       if (*p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET)
          {
          escape = ESC_k;
          break;
-Line 914 
 else
+Line 918 
 else
      else negated = FALSE;
      /* The integer range is limited by the machine's int representation. */
-     c = 0;
+     s = 0;
+     overflow = FALSE;
      while (IS_DIGIT(ptr[1]))
        {
-       if (((unsigned int)c) > INT_MAX / 10) /* Integer overflow */
+       if (s > INT_MAX / 10 - 1) /* Integer overflow */
          {
-         c = -1;
+         overflow = TRUE;
          break;
          }
-       c = c * 10 + *(++ptr) - CHAR_0;
+       s = s * 10 + (int)(*(++ptr) - CHAR_0);
        }
-     if (((unsigned int)c) > INT_MAX) /* Integer overflow */
+     if (overflow) /* Integer overflow */
        {
        while (IS_DIGIT(ptr[1]))
          ptr++;
-Line 938 
 else
+Line 943 
 else
        break;
        }
-     if (c == 0)
+     if (s == 0)
        {
        *errorcodeptr = ERR58;
        break;
-Line 946 
 else
+Line 951 
 else
      if (negated)
        {
-       if (c > bracount)
+       if (s > bracount)
          {
          *errorcodeptr = ERR15;
          break;
          }
-       c = bracount - (c - 1);
+       s = bracount - (s - 1);
        }
-     escape = ESC_REF + c;
+     escape = -s;
      break;
      /* The handling of escape sequences consisting of a string of digits
-Line 976 
 else
+Line 981 
 else
        {
        oldptr = ptr;
        /* The integer range is limited by the machine's int representation. */
-       c -= CHAR_0;
+       s = (int)(c -CHAR_0);
+       overflow = FALSE;
        while (IS_DIGIT(ptr[1]))
          {
-         if (((unsigned int)c) > INT_MAX / 10) /* Integer overflow */
+         if (s > INT_MAX / 10 - 1) /* Integer overflow */
            {
-           c = -1;
+           overflow = TRUE;
            break;
            }
-         c = c * 10 + *(++ptr) - CHAR_0;
+         s = s * 10 + (int)(*(++ptr) - CHAR_0);
          }
-       if (((unsigned int)c) > INT_MAX) /* Integer overflow */
+       if (overflow) /* Integer overflow */
          {
          while (IS_DIGIT(ptr[1]))
            ptr++;
          *errorcodeptr = ERR61;
          break;
          }
-       if (c < 10 || c <= bracount)
+       if (s < 10 || s <= bracount)
          {
-         escape = ESC_REF + c;
+         escape = -s;
          break;
          }
        ptr = oldptr;      /* Put the pointer back and fall through */
-Line 1042 
 else
+Line 1048 
 else
          c = 0;
          for (i = 0; i < 2; ++i)
            {
-           register int cc = *(++ptr);
+           register pcre_uint32 cc = *(++ptr);
  #ifndef EBCDIC  /* ASCII/UTF-8 coding */
            if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
            c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
-Line 1060 
 else
+Line 1066 
 else
        const pcre_uchar *pt = ptr + 2;
        c = 0;
+       overflow = FALSE;
        while (MAX_255(*pt) && (digitab[*pt] & ctype_xdigit) != 0)
          {
-         register int cc = *pt++;
+         register pcre_uint32 cc = *pt++;
          if (c == 0 && cc == CHAR_0) continue;     /* Leading zeroes */
+ #ifdef COMPILE_PCRE32
+         if (c >= 0x10000000l) { overflow = TRUE; break; }
+ #endif
  #ifndef EBCDIC  /* ASCII/UTF-8 coding */
          if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
          c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
-Line 1074 
 else
+Line 1085 
 else
  #endif
  #if defined COMPILE_PCRE8
-         if (c > (utf ? 0x10ffff : 0xff)) { c = -1; break; }
+         if (c > (utf ? 0x10ffff : 0xff)) { overflow = TRUE; break; }
  #elif defined COMPILE_PCRE16
-         if (c > (utf ? 0x10ffff : 0xffff)) { c = -1; break; }
+         if (c > (utf ? 0x10ffff : 0xffff)) { overflow = TRUE; break; }
  #elif defined COMPILE_PCRE32
-         if (utf && c > 0x10ffff) { c = -1; break; }
+         if (utf && c > 0x10ffff) { overflow = TRUE; break; }
  #endif
          }
-       if (c < 0)
+       if (overflow)
          {
          while (MAX_255(*pt) && (digitab[*pt] & ctype_xdigit) != 0) pt++;
          *errorcodeptr = ERR34;
-Line 1104 
 else
+Line 1115 
 else
      c = 0;
      while (i++ < 2 && MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0)
        {
-       int cc;                                  /* Some compilers don't like */
+       pcre_uint32 cc;                          /* Some compilers don't like */
        cc = *(++ptr);                           /* ++ in initializers */
  #ifndef EBCDIC  /* ASCII/UTF-8 coding */
        if (cc >= CHAR_a) cc -= 32;              /* Convert to upper case */
-Line 1123 
 else
+Line 1134 
 else
      case CHAR_c:
      c = *(++ptr);
-     if (c == 0)
+     if (c == CHAR_NULL)
        {
        *errorcodeptr = ERR2;
        break;
-Line 1192 
 escape sequence.
+Line 1203 
 escape sequence.
  Argument:
    ptrptr         points to the pattern position pointer
    negptr         points to a boolean that is set TRUE for negation else FALSE
-   dptr           points to an int that is set to the detailed property value
+   ptypeptr       points to an unsigned int that is set to the type value
+   pdataptr       points to an unsigned int that is set to the detailed property value
    errorcodeptr   points to the error code variable
- Returns:         type value from ucp_type_table, or -1 for an invalid type
+ Returns:         TRUE if the type value was found, or FALSE for an invalid type
  */
- static int
+ static BOOL
- get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, int *dptr, int *errorcodeptr)
+ get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, unsigned int *ptypeptr,
+   unsigned int *pdataptr, int *errorcodeptr)
  {
- int c, i, bot, top;
+ pcre_uchar c;
+ int i, bot, top;
  const pcre_uchar *ptr = *ptrptr;
  pcre_uchar name[32];
  c = *(++ptr);
- if (c == 0) goto ERROR_RETURN;
+ if (c == CHAR_NULL) goto ERROR_RETURN;
  *negptr = FALSE;
-Line 1223 
 if (c == CHAR_LEFT_CURLY_BRACKET)
+Line 1237 
 if (c == CHAR_LEFT_CURLY_BRACKET)
    for (i = 0; i < (int)(sizeof(name) / sizeof(pcre_uchar)) - 1; i++)
      {
      c = *(++ptr);
-     if (c == 0) goto ERROR_RETURN;
+     if (c == CHAR_NULL) goto ERROR_RETURN;
      if (c == CHAR_RIGHT_CURLY_BRACKET) break;
      name[i] = c;
      }
-Line 1248 
 top = PRIV(utt_size);
+Line 1262 
 top = PRIV(utt_size);
  while (bot < top)
    {
+   int r;
    i = (bot + top) >> 1;
-   c = STRCMP_UC_C8(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);
+   r = STRCMP_UC_C8(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);
-   if (c == 0)
+   if (r == 0)
      {
-     *dptr = PRIV(utt)[i].value;
+     *ptypeptr = PRIV(utt)[i].type;
-     return PRIV(utt)[i].type;
+     *pdataptr = PRIV(utt)[i].value;
+     return TRUE;
      }
-   if (c > 0) bot = i + 1; else top = i;
+   if (r > 0) bot = i + 1; else top = i;
    }
  *errorcodeptr = ERR47;
  *ptrptr = ptr;
- return -1;
+ return FALSE;
  ERROR_RETURN:
  *errorcodeptr = ERR46;
  *ptrptr = ptr;
- return -1;
+ return FALSE;
  }
  #endif
-Line 1300 
 int max = -1;
+Line 1316 
 int max = -1;
  /* Read the minimum value and do a paranoid check: a negative value indicates
  an integer overflow. */
- while (IS_DIGIT(*p)) min = min * 10 + *p++ - CHAR_0;
+ while (IS_DIGIT(*p)) min = min * 10 + (int)(*p++ - CHAR_0);
  if (min < 0 || min > 65535)
    {
    *errorcodeptr = ERR5;
-Line 1315 
 if (*p == CHAR_RIGHT_CURLY_BRACKET) max
+Line 1331 
 if (*p == CHAR_RIGHT_CURLY_BRACKET) max
    if (*(++p) != CHAR_RIGHT_CURLY_BRACKET)
      {
      max = 0;
-     while(IS_DIGIT(*p)) max = max * 10 + *p++ - CHAR_0;
+     while(IS_DIGIT(*p)) max = max * 10 + (int)(*p++ - CHAR_0);
      if (max < 0 || max > 65535)
        {
        *errorcodeptr = ERR5;
-Line 1416 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
+Line 1432 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
    else if (ptr[2] == CHAR_NUMBER_SIGN)
      {
-     for (ptr += 3; *ptr != 0; ptr++) if (*ptr == CHAR_RIGHT_PARENTHESIS) break;
+     for (ptr += 3; *ptr != CHAR_NULL; ptr++)
+       if (*ptr == CHAR_RIGHT_PARENTHESIS) break;
      goto FAIL_EXIT;
      }
-Line 1429 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
+Line 1446 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
      ptr += 2;
      if (ptr[1] != CHAR_QUESTION_MARK)
        {
-       while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
+       while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
-       if (*ptr != 0) ptr++;
+       if (*ptr != CHAR_NULL) ptr++;
        }
      }
-Line 1446 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
+Line 1463 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
      if ((*ptr == CHAR_LESS_THAN_SIGN && ptr[1] != CHAR_EXCLAMATION_MARK &&
          ptr[1] != CHAR_EQUALS_SIGN) || *ptr == CHAR_APOSTROPHE)
        {
-       int term;
+       pcre_uchar term;
        const pcre_uchar *thisname;
        *count += 1;
        if (name == NULL && *count == lorn) return *count;
-Line 1454 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
+Line 1471 
 if (ptr[0] == CHAR_LEFT_PARENTHESIS)
        if (term == CHAR_LESS_THAN_SIGN) term = CHAR_GREATER_THAN_SIGN;
        thisname = ptr;
        while (*ptr != term) ptr++;
-       if (name != NULL && lorn == ptr - thisname &&
+       if (name != NULL && lorn == (int)(ptr - thisname) &&
-           STRNCMP_UC_UC(name, thisname, lorn) == 0)
+           STRNCMP_UC_UC(name, thisname, (unsigned int)lorn) == 0)
          return *count;
        term++;
        }
-Line 1473 
 for (; ptr < cd->end_pattern; ptr++)
+Line 1490 
 for (; ptr < cd->end_pattern; ptr++)
    if (*ptr == CHAR_BACKSLASH)
      {
-     if (*(++ptr) == 0) goto FAIL_EXIT;
+     if (*(++ptr) == CHAR_NULL) goto FAIL_EXIT;
      if (*ptr == CHAR_Q) for (;;)
        {
-       while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};
+       while (*(++ptr) != CHAR_NULL && *ptr != CHAR_BACKSLASH) {};
-       if (*ptr == 0) goto FAIL_EXIT;
+       if (*ptr == CHAR_NULL) goto FAIL_EXIT;
        if (*(++ptr) == CHAR_E) break;
        }
      continue;
-Line 1521 
 for (; ptr < cd->end_pattern; ptr++)
+Line 1538 
 for (; ptr < cd->end_pattern; ptr++)
      while (*(++ptr) != CHAR_RIGHT_SQUARE_BRACKET)
        {
-       if (*ptr == 0) return -1;
+       if (*ptr == CHAR_NULL) return -1;
        if (*ptr == CHAR_BACKSLASH)
          {
-         if (*(++ptr) == 0) goto FAIL_EXIT;
+         if (*(++ptr) == CHAR_NULL) goto FAIL_EXIT;
          if (*ptr == CHAR_Q) for (;;)
            {
-           while (*(++ptr) != 0 && *ptr != CHAR_BACKSLASH) {};
+           while (*(++ptr) != CHAR_NULL && *ptr != CHAR_BACKSLASH) {};
-           if (*ptr == 0) goto FAIL_EXIT;
+           if (*ptr == CHAR_NULL) goto FAIL_EXIT;
            if (*(++ptr) == CHAR_E) break;
            }
          continue;
-Line 1542 
 for (; ptr < cd->end_pattern; ptr++)
+Line 1559 
 for (; ptr < cd->end_pattern; ptr++)
    if (xmode && *ptr == CHAR_NUMBER_SIGN)
      {
      ptr++;
-     while (*ptr != 0)
+     while (*ptr != CHAR_NULL)
        {
        if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }
        ptr++;
-Line 1550 
 for (; ptr < cd->end_pattern; ptr++)
+Line 1567 
 for (; ptr < cd->end_pattern; ptr++)
        if (utf) FORWARDCHAR(ptr);
  #endif
        }
-     if (*ptr == 0) goto FAIL_EXIT;
+     if (*ptr == CHAR_NULL) goto FAIL_EXIT;
      continue;
      }
-Line 1560 
 for (; ptr < cd->end_pattern; ptr++)
+Line 1577 
 for (; ptr < cd->end_pattern; ptr++)
      {
      int rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf, count);
      if (rc > 0) return rc;
-     if (*ptr == 0) goto FAIL_EXIT;
+     if (*ptr == CHAR_NULL) goto FAIL_EXIT;
      }
    else if (*ptr == CHAR_RIGHT_PARENTHESIS)
-Line 1625 
 matching closing parens. That is why we
+Line 1642 
 matching closing parens. That is why we
  for (;;)
    {
    rc = find_parens_sub(&ptr, cd, name, lorn, xmode, utf, &count);
-   if (rc > 0 || *ptr++ == 0) break;
+   if (rc > 0 || *ptr++ == CHAR_NULL) break;
    }
  return rc;
-Line 1733 
 for (;;)
+Line 1750 
 for (;;)
    {
    int d;
    pcre_uchar *ce, *cs;
-   register int op = *cc;
+   register pcre_uchar op = *cc;
    switch (op)
      {
-Line 1841 
 for (;;)
+Line 1858 
 for (;;)
      case OP_NOTI:
      branchlength++;
      cc += 2;
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ #ifdef SUPPORT_UTF
      if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
      break;
-Line 1853 
 for (;;)
+Line 1870 
 for (;;)
      case OP_EXACTI:
      case OP_NOTEXACT:
      case OP_NOTEXACTI:
-     branchlength += GET2(cc,1);
+     branchlength += (int)GET2(cc,1);
      cc += 2 + IMM2_SIZE;
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ #ifdef SUPPORT_UTF
      if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
  #endif
      break;
-Line 1898 
 for (;;)
+Line 1915 
 for (;;)
      /* Check a class for variable quantification */
- #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
-     case OP_XCLASS:
-     cc += GET(cc, 1) - PRIV(OP_lengths)[OP_CLASS];
-     /* Fall through */
- #endif
      case OP_CLASS:
      case OP_NCLASS:
+ #if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+     case OP_XCLASS:
+     /* The original code caused an unsigned overflow in 64 bit systems,
+     so now we use a conditional statement. */
+     if (op == OP_XCLASS)
+       cc += GET(cc, 1);
+     else
+       cc += PRIV(OP_lengths)[OP_CLASS];
+ #else
      cc += PRIV(OP_lengths)[OP_CLASS];
+ #endif
      switch (*cc)
        {
-Line 1921 
 for (;;)
+Line 1942 
 for (;;)
        case OP_CRRANGE:
        case OP_CRMINRANGE:
        if (GET2(cc,1) != GET2(cc,1+IMM2_SIZE)) return -1;
-       branchlength += GET2(cc,1);
+       branchlength += (int)GET2(cc,1);
        cc += 1 + 2 * IMM2_SIZE;
        break;
-Line 2048 
 PRIV(find_bracket)(const pcre_uchar *cod
+Line 2069 
 PRIV(find_bracket)(const pcre_uchar *cod
  {
  for (;;)
    {
-   register int c = *code;
+   register pcre_uchar c = *code;
    if (c == OP_END) return NULL;
-Line 2071 
 for (;;)
+Line 2092 
 for (;;)
    else if (c == OP_CBRA || c == OP_SCBRA ||
             c == OP_CBRAPOS || c == OP_SCBRAPOS)
      {
-     int n = GET2(code, 1+LINK_SIZE);
+     int n = (int)GET2(code, 1+LINK_SIZE);
      if (n == number) return (pcre_uchar *)code;
      code += PRIV(OP_lengths)[c];
      }
-Line 2186 
 find_recurse(const pcre_uchar *code, BOO
+Line 2207 
 find_recurse(const pcre_uchar *code, BOO
  {
  for (;;)
    {
-   register int c = *code;
+   register pcre_uchar c = *code;
    if (c == OP_END) return NULL;
    if (c == OP_RECURSE) return code;
-Line 2340 
 static BOOL
+Line 2361 
 static BOOL
  could_be_empty_branch(const pcre_uchar *code, const pcre_uchar *endcode,
    BOOL utf, compile_data *cd)
  {
- register int c;
+ register pcre_uchar c;
  for (code = first_significant_code(code + PRIV(OP_lengths)[*code], TRUE);
       code < endcode;
       code = first_significant_code(code + PRIV(OP_lengths)[c], TRUE))
-Line 2374 
 for (code = first_significant_code(code
+Line 2395 
 for (code = first_significant_code(code
      /* Test for forward reference */
      for (scode = cd->start_workspace; scode < cd->hwm; scode += LINK_SIZE)
-       if (GET(scode, 0) == code + 1 - cd->start_code) return TRUE;
+       if ((int)GET(scode, 0) == (int)(code + 1 - cd->start_code)) return TRUE;
      /* Not a forward reference, test for completed backward reference */
-Line 2695 
 Returns:   TRUE or FALSE
+Line 2716 
 Returns:   TRUE or FALSE
  static BOOL
  check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr)
  {
- int terminator;          /* Don't combine these lines; the Solaris cc */
+ pcre_uchar terminator;          /* Don't combine these lines; the Solaris cc */
  terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
- for (++ptr; *ptr != 0; ptr++)
+ for (++ptr; *ptr != CHAR_NULL; ptr++)
    {
    if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
      ptr++;
-Line 2744 
 register int yield = 0;
+Line 2765 
 register int yield = 0;
  while (posix_name_lengths[yield] != 0)
    {
    if (len == posix_name_lengths[yield] &&
-     STRNCMP_UC_C8(ptr, pn, len) == 0) return yield;
+     STRNCMP_UC_C8(ptr, pn, (unsigned int)len) == 0) return yield;
    pn += posix_name_lengths[yield] + 1;
    yield++;
    }
-Line 2799 
 while ((ptr = (pcre_uchar *)find_recurse
+Line 2820 
 while ((ptr = (pcre_uchar *)find_recurse
    for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)
      {
-     offset = GET(hc, 0);
+     offset = (int)GET(hc, 0);
      if (cd->start_code + offset == ptr + 1)
        {
        PUT(hc, 0, offset + adjust);
-Line 2812 
 while ((ptr = (pcre_uchar *)find_recurse
+Line 2833 
 while ((ptr = (pcre_uchar *)find_recurse
    if (hc >= cd->hwm)
      {
-     offset = GET(ptr, 1);
+     offset = (int)GET(ptr, 1);
      if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
      }
-Line 2898 
 Yield:        -1 when no more
+Line 2919 
 Yield:        -1 when no more
  */
  static int
- get_othercase_range(unsigned int *cptr, unsigned int d, unsigned int *ocptr,
+ get_othercase_range(pcre_uint32 *cptr, pcre_uint32 d, pcre_uint32 *ocptr,
-   unsigned int *odptr)
+   pcre_uint32 *odptr)
  {
- unsigned int c, othercase, next;
+ pcre_uint32 c, othercase, next;
- int co;
+ unsigned int co;
  /* Find the first character that has an other case. If it has multiple other
  cases, return its case offset value. */
-Line 2913 
 for (c = *cptr; c <= d; c++)
+Line 2934 
 for (c = *cptr; c <= d; c++)
      {
      *ocptr = c++;   /* Character that has the set */
      *cptr = c;      /* Rest of input range */
-     return co;
+     return (int)co;
      }
    if ((othercase = UCD_OTHERCASE(c)) != c) break;
    }
-Line 2953 
 Returns:       TRUE if auto-possessifyin
+Line 2974 
 Returns:       TRUE if auto-possessifyin
  */
  static BOOL
- check_char_prop(int c, int ptype, int pdata, BOOL negated)
+ check_char_prop(pcre_uint32 c, unsigned int ptype, unsigned int pdata, BOOL negated)
  {
  #ifdef SUPPORT_UCP
  const pcre_uint32 *p;
-Line 3004 
 switch(ptype)
+Line 3025 
 switch(ptype)
    p = PRIV(ucd_caseless_sets) + prop->caseset;
    for (;;)
      {
-     if ((unsigned int)c < *p) return !negated;
+     if (c < *p) return !negated;
-     if ((unsigned int)c == *p++) return negated;
+     if (c == *p++) return negated;
      }
    break;  /* Control never reaches here */
  #endif
-Line 3039 
 static BOOL
+Line 3060 
 static BOOL
  check_auto_possessive(const pcre_uchar *previous, BOOL utf,
    const pcre_uchar *ptr, int options, compile_data *cd)
  {
- pcre_int32 c = NOTACHAR; // FIXMEchpe pcre_uint32
+ pcre_uint32 c = NOTACHAR;
- pcre_int32 next;
+ pcre_uint32 next;
  int escape;
- int op_code = *previous++;
+ pcre_uchar op_code = *previous++;
  /* Skip whitespace and comments in extended mode */
-Line 3054 
 if ((options & PCRE_EXTENDED) != 0)
+Line 3075 
 if ((options & PCRE_EXTENDED) != 0)
      if (*ptr == CHAR_NUMBER_SIGN)
        {
        ptr++;
-       while (*ptr != 0)
+       while (*ptr != CHAR_NULL)
          {
          if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
          ptr++;
-Line 3097 
 if ((options & PCRE_EXTENDED) != 0)
+Line 3118 
 if ((options & PCRE_EXTENDED) != 0)
      if (*ptr == CHAR_NUMBER_SIGN)
        {
        ptr++;
-       while (*ptr != 0)
+       while (*ptr != CHAR_NULL)
          {
          if (IS_NEWLINE(ptr)) { ptr += cd->nllen; break; }
          ptr++;
-Line 3120 
 if (*ptr == CHAR_ASTERISK || *ptr == CHA
+Line 3141 
 if (*ptr == CHAR_ASTERISK || *ptr == CHA
  if (op_code == OP_CHAR || op_code == OP_CHARI ||
      op_code == OP_NOT || op_code == OP_NOTI)
-   //if (escape == 0) switch(op_code)
    {
  #ifdef SUPPORT_UTF
    GETCHARTEST(c, previous);
-Line 3138 
 if (escape == 0)
+Line 3158 
 if (escape == 0)
    case, which maps to the special PT_CLIST property. Check this first. */
  #ifdef SUPPORT_UCP
-   if (utf && (unsigned int)c != NOTACHAR && (options & PCRE_CASELESS) != 0)
+   if (utf && c != NOTACHAR && (options & PCRE_CASELESS) != 0)
      {
-     int ocs = UCD_CASESET(next);
+     unsigned int ocs = UCD_CASESET(next);
      if (ocs > 0) return check_char_prop(c, PT_CLIST, ocs, op_code >= OP_NOT);
      }
  #endif
-Line 3160 
 if (escape == 0)
+Line 3180 
 if (escape == 0)
  #ifdef SUPPORT_UTF
      if (utf)
        {
-       unsigned int othercase;
+       pcre_uint32 othercase;
        if (next < 128) othercase = cd->fcc[next]; else
  #ifdef SUPPORT_UCP
-       othercase = UCD_OTHERCASE((unsigned int)next);
+       othercase = UCD_OTHERCASE(next);
  #else
        othercase = NOTACHAR;
  #endif
-       return (unsigned int)c != othercase;
+       return c != othercase;
        }
      else
  #endif  /* SUPPORT_UTF */
-     return (c != TABLE_GET((unsigned int)next, cd->fcc, next));  /* Not UTF */
+     return (c != TABLE_GET(next, cd->fcc, next));  /* Not UTF */
      case OP_NOT:
      return c == next;
-Line 3181 
 if (escape == 0)
+Line 3201 
 if (escape == 0)
  #ifdef SUPPORT_UTF
      if (utf)
        {
-       unsigned int othercase;
+       pcre_uint32 othercase;
        if (next < 128) othercase = cd->fcc[next]; else
  #ifdef SUPPORT_UCP
-       othercase = UCD_OTHERCASE((unsigned int)next);
+       othercase = UCD_OTHERCASE(next);
  #else
        othercase = NOTACHAR;
  #endif
-       return (unsigned int)c == othercase;
+       return c == othercase;
        }
      else
  #endif  /* SUPPORT_UTF */
-     return (c == TABLE_GET((unsigned int)next, cd->fcc, next));  /* Not UTF */
+     return (c == TABLE_GET(next, cd->fcc, next));  /* Not UTF */
      /* 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. */
-Line 3326 
 switch(op_code)
+Line 3346 
 switch(op_code)
      case ESC_p:
      case ESC_P:
        {
-       int ptype, pdata, errorcodeptr;
+       unsigned int ptype = 0, pdata = 0;
+       int errorcodeptr;
        BOOL negated;
        ptr--;      /* Make ptr point at the p or P */
-       ptype = get_ucp(&ptr, &negated, &pdata, &errorcodeptr);
+       if (!get_ucp(&ptr, &negated, &ptype, &pdata, &errorcodeptr))
-       if (ptype < 0) return FALSE;
+         return FALSE;
        ptr++;      /* Point past the final curly ket */
        /* If the property item is optional, we have to give up. (When generated
-Line 3655 
 Arguments:
+Line 3676 
 Arguments:
    codeptr        points to the pointer to the current code point
    ptrptr         points to the current pattern pointer
    errorcodeptr   points to error code variable
-   firstcharptr   set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
+   firstcharptr    place to put the first required character
-   reqcharptr     set to the last literal character required, else < 0
+   firstcharflagsptr place to put the first character flags, or a negative number
+   reqcharptr     place to put the last required character
+   reqcharflagsptr place to put the last required character flags, or a negative number
    bcptr          points to current branch chain
    cond_depth     conditional nesting depth
    cd             contains pointers to tables etc.
-Line 3669 
 Returns:         TRUE on success
+Line 3692 
 Returns:         TRUE on success
  static BOOL
  compile_branch(int *optionsptr, pcre_uchar **codeptr,
-   const pcre_uchar **ptrptr, int *errorcodeptr, pcre_int32 *firstcharptr,
+   const pcre_uchar **ptrptr, int *errorcodeptr,
-   pcre_int32 *reqcharptr, branch_chain *bcptr, int cond_depth,
+   pcre_uint32 *firstcharptr, pcre_int32 *firstcharflagsptr,
+   pcre_uint32 *reqcharptr, pcre_int32 *reqcharflagsptr,
+   branch_chain *bcptr, int cond_depth,
    compile_data *cd, int *lengthptr)
  {
  int repeat_type, op_type;
  int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
  int bravalue = 0;
  int greedy_default, greedy_non_default;
- pcre_int32 firstchar, reqchar;
+ pcre_uint32 firstchar, reqchar;
- pcre_int32 zeroreqchar, zerofirstchar;
+ pcre_int32 firstcharflags, reqcharflags;
+ pcre_uint32 zeroreqchar, zerofirstchar;
+ pcre_int32 zeroreqcharflags, zerofirstcharflags;
  pcre_int32 req_caseopt, reqvary, tempreqvary;
  int options = *optionsptr;               /* May change dynamically */
  int after_manual_callout = 0;
  int length_prevgroup = 0;
- register int c;
+ register pcre_uint32 c;
  int escape;
  register pcre_uchar *code = *codeptr;
  pcre_uchar *last_code = code;
-Line 3706 
 dynamically as we process the pattern. *
+Line 3733 
 dynamically as we process the pattern. *
  #ifdef SUPPORT_UTF
  /* PCRE_UTF[16|32] have the same value as PCRE_UTF8. */
  BOOL utf = (options & PCRE_UTF8) != 0;
+ #ifndef COMPILE_PCRE32
  pcre_uchar utf_chars[6];
+ #endif
  #else
  BOOL utf = FALSE;
  #endif
-Line 3741 
 to take the zero repeat into account. Th
+Line 3770 
 to take the zero repeat into account. Th
  zerofirstbyte and zeroreqchar when such a repeat is encountered. The individual
  item types that can be repeated set these backoff variables appropriately. */
- firstchar = reqchar = zerofirstchar = zeroreqchar = REQ_UNSET;
+ firstchar = reqchar = zerofirstchar = zeroreqchar = 0;
+ firstcharflags = reqcharflags = zerofirstcharflags = zeroreqcharflags = REQ_UNSET;
  /* The variable req_caseopt contains either the REQ_CASELESS value
  or zero, according to the current setting of the caseless flag. The
-Line 3767 
 for (;; ptr++)
+Line 3797 
 for (;; ptr++)
    int recno;
    int refsign;
    int skipbytes;
-   int subreqchar;
+   pcre_uint32 subreqchar, subfirstchar;
-   int subfirstchar;
+   pcre_int32 subreqcharflags, subfirstcharflags;
    int terminator;
-   int mclength;
+   unsigned int mclength;
-   int tempbracount;
+   unsigned int tempbracount;
-   int ec; // FIXMEchpe pcre_uint32
+   pcre_uint32 ec;
    pcre_uchar mcbuffer[8];
    /* Get next character in the pattern */
-Line 3782 
 for (;; ptr++)
+Line 3812 
 for (;; 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)
+   if (c == CHAR_NULL && nestptr != NULL)
      {
      ptr = nestptr;
      nestptr = NULL;
-Line 3857 
 for (;; ptr++)
+Line 3887 
 for (;; ptr++)
    /* If in \Q...\E, check for the end; if not, we have a literal */
-   if (inescq && c != 0)
+   if (inescq && c != CHAR_NULL)
      {
      if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)
        {
-Line 3905 
 for (;; ptr++)
+Line 3935 
 for (;; ptr++)
      if (c == CHAR_NUMBER_SIGN)
        {
        ptr++;
-       while (*ptr != 0)
+       while (*ptr != CHAR_NULL)
          {
          if (IS_NEWLINE(ptr)) { ptr += cd->nllen - 1; break; }
          ptr++;
-Line 3913 
 for (;; ptr++)
+Line 3943 
 for (;; ptr++)
          if (utf) FORWARDCHAR(ptr);
  #endif
          }
-       if (*ptr != 0) continue;
+       if (*ptr != CHAR_NULL) continue;
        /* Else fall through to handle end of string */
        c = 0;
-Line 3935 
 for (;; ptr++)
+Line 3965 
 for (;; ptr++)
      case CHAR_VERTICAL_LINE:       /* or | or ) */
      case CHAR_RIGHT_PARENTHESIS:
      *firstcharptr = firstchar;
+     *firstcharflagsptr = firstcharflags;
      *reqcharptr = reqchar;
+     *reqcharflagsptr = reqcharflags;
      *codeptr = code;
      *ptrptr = ptr;
      if (lengthptr != NULL)
-Line 3959 
 for (;; ptr++)
+Line 3991 
 for (;; ptr++)
      previous = NULL;
      if ((options & PCRE_MULTILINE) != 0)
        {
-       if (firstchar == REQ_UNSET) firstchar = REQ_NONE;
+       if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
        *code++ = OP_CIRCM;
        }
      else *code++ = OP_CIRC;
-Line 3974 
 for (;; ptr++)
+Line 4006 
 for (;; ptr++)
      repeats. The value of reqchar doesn't change either. */
      case CHAR_DOT:
-     if (firstchar == REQ_UNSET) firstchar = REQ_NONE;
+     if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
      zerofirstchar = firstchar;
+     zerofirstcharflags = firstcharflags;
      zeroreqchar = reqchar;
+     zeroreqcharflags = reqcharflags;
      previous = code;
      *code++ = ((options & PCRE_DOTALL) != 0)? OP_ALLANY: OP_ANY;
      break;
-Line 4050 
 for (;; ptr++)
+Line 4084 
 for (;; ptr++)
          (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
        {
        *code++ = negate_class? OP_ALLANY : OP_FAIL;
-       if (firstchar == REQ_UNSET) firstchar = REQ_NONE;
+       if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
        zerofirstchar = firstchar;
+       zerofirstcharflags = firstcharflags;
        break;
        }
-Line 4086 
 for (;; ptr++)
+Line 4121 
 for (;; ptr++)
      means that an initial ] is taken as a data character. At the start of the
      loop, c contains the first byte of the character. */
-     if (c != 0) do
+     if (c != CHAR_NULL) do
        {
        const pcre_uchar *oldptr;
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ #ifdef SUPPORT_UTF
        if (utf && HAS_EXTRALEN(c))
          {                           /* Braces are required because the */
          GETCHARLEN(c, ptr, ptr);    /* macro generates multiple statements */
-Line 4349 
 for (;; ptr++)
+Line 4384 
 for (;; ptr++)
              case ESC_P:
                {
                BOOL negated;
-               int pdata;
+               unsigned int ptype = 0, pdata = 0;
-               int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
+               if (!get_ucp(&ptr, &negated, &ptype, &pdata, errorcodeptr))
-               if (ptype < 0) goto FAILED;
+                 goto FAILED;
                *class_uchardata++ = ((escape == ESC_p) != negated)?
                  XCL_PROP : XCL_NOTPROP;
                *class_uchardata++ = ptype;
-Line 4405 
 for (;; ptr++)
+Line 4440 
 for (;; ptr++)
        if (!inescq && ptr[1] == CHAR_MINUS)
          {
-         int d;
+         pcre_uint32 d;
          ptr += 2;
          while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E) ptr += 2;
-Line 4424 
 for (;; ptr++)
+Line 4459 
 for (;; ptr++)
          /* 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))
+         if (*ptr == CHAR_NULL || (!inescq && *ptr == CHAR_RIGHT_SQUARE_BRACKET))
            {
            ptr = oldptr;
            goto CLASS_SINGLE_CHARACTER;
-Line 4453 
 for (;; ptr++)
+Line 4488 
 for (;; ptr++)
            /* \b is backspace; any other special means the '-' was literal. */
-           if (descape > 0)
+           if (descape != 0)
              {
              if (descape == ESC_b) d = CHAR_BS; else
                {
-Line 4511 
 for (;; ptr++)
+Line 4546 
 for (;; ptr++)
          {
          ptr++;
          zeroreqchar = reqchar;
+         zeroreqcharflags = reqcharflags;
          if (negate_class)
            {
  #ifdef SUPPORT_UCP
-             // FIXMEchpe pcreuint32?
            int d;
  #endif
-           if (firstchar == REQ_UNSET) firstchar = REQ_NONE;
+           if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
            zerofirstchar = firstchar;
+           zerofirstcharflags = firstcharflags;
            /* For caseless UTF-8 mode when UCP support is available, check
            whether this character has more than one other case. If so, generate
-Line 4578 
 for (;; ptr++)
+Line 4614 
 for (;; ptr++)
      If we are at the end of an internal nested string, revert to the outer
      string. */
-     while (((c = *(++ptr)) != 0 ||
+     while (((c = *(++ptr)) != CHAR_NULL ||
             (nestptr != NULL &&
-              (ptr = nestptr, nestptr = NULL, c = *(++ptr)) != 0)) &&
+              (ptr = nestptr, nestptr = NULL, c = *(++ptr)) != CHAR_NULL)) &&
             (c != CHAR_RIGHT_SQUARE_BRACKET || inescq));
      /* Check for missing terminating ']' */
-     if (c == 0)
+     if (c == CHAR_NULL)
        {
        *errorcodeptr = ERR6;
        goto FAILED;
-Line 4607 
 for (;; ptr++)
+Line 4643 
 for (;; ptr++)
      setting, whatever the repeat count. Any reqchar setting must remain
      unchanged after any kind of repeat. */
-     if (firstchar == REQ_UNSET) firstchar = REQ_NONE;
+     if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
      zerofirstchar = firstchar;
+     zerofirstcharflags = firstcharflags;
      zeroreqchar = reqchar;
+     zeroreqcharflags = reqcharflags;
      /* If there are characters with values > 255, we have to compile an
      extended class, with its own opcode, unless there was a negated special
-Line 4704 
 for (;; ptr++)
+Line 4742 
 for (;; ptr++)
      if (repeat_min == 0)
        {
        firstchar = zerofirstchar;    /* Adjust for zero repeat */
+       firstcharflags = zerofirstcharflags;
        reqchar = zeroreqchar;        /* Ditto */
+       reqcharflags = zeroreqcharflags;
        }
      /* Remember whether this is a variable length repeat */
-Line 4807 
 for (;; ptr++)
+Line 4847 
 for (;; ptr++)
          {
          c = code[-1];
          if (*previous <= OP_CHARI && repeat_min > 1)
-           reqchar = c | req_caseopt | cd->req_varyopt;
+           {
+           reqchar = c;
+           reqcharflags = req_caseopt | cd->req_varyopt;
+           }
          }
        /* If the repetition is unlimited, it pays to see if the next thing on
-Line 5189 
 for (;; ptr++)
+Line 5232 
 for (;; ptr++)
            else
              {
-             if (groupsetfirstchar && reqchar < 0) reqchar = firstchar;
+             if (groupsetfirstchar && reqcharflags < 0)
+               {
+               reqchar = firstchar;
+               reqcharflags = firstcharflags;
+               }
              for (i = 1; i < repeat_min; i++)
                {
-Line 5468 
 for (;; ptr++)
+Line 5515 
 for (;; ptr++)
        else if (*tempcode == OP_EXACT || *tempcode == OP_NOTEXACT)
          {
          tempcode += PRIV(OP_lengths)[*tempcode];
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ #ifdef SUPPORT_UTF
          if (utf && HAS_EXTRALEN(tempcode[-1]))
            tempcode += GET_EXTRALEN(tempcode[-1]);
  #endif
-Line 5564 
 for (;; ptr++)
+Line 5611 
 for (;; ptr++)
        if (*ptr == CHAR_COLON)
          {
          arg = ++ptr;
-         while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
+         while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
          arglen = (int)(ptr - arg);
          if ((unsigned int)arglen > MAX_MARK)
            {
-Line 5609 
 for (;; ptr++)
+Line 5656 
 for (;; ptr++)
                (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;
              /* Do not set firstchar after *ACCEPT */
-             if (firstchar == REQ_UNSET) firstchar = REQ_NONE;
+             if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
              }
            /* Handle other cases with/without an argument */
-Line 5678 
 for (;; ptr++)
+Line 5725 
 for (;; ptr++)
          {
          case CHAR_NUMBER_SIGN:                 /* Comment; skip to ket */
          ptr++;
-         while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
+         while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
-         if (*ptr == 0)
+         if (*ptr == CHAR_NULL)
            {
            *errorcodeptr = ERR18;
            goto FAILED;
-Line 5755 
 for (;; ptr++)
+Line 5802 
 for (;; ptr++)
            }
          else
            {
-           terminator = 0;
+           terminator = CHAR_NULL;
            if (ptr[1] == CHAR_MINUS || ptr[1] == CHAR_PLUS) refsign = *(++ptr);
            }
-Line 5775 
 for (;; ptr++)
+Line 5822 
 for (;; ptr++)
          while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0)
            {
            if (recno >= 0)
-             recno = (IS_DIGIT(*ptr))? recno * 10 + *ptr - CHAR_0 : -1;
+             recno = (IS_DIGIT(*ptr))? recno * 10 + (int)(*ptr - CHAR_0) : -1;
            ptr++;
            }
          namelen = (int)(ptr - name);
-         if ((terminator > 0 && *ptr++ != terminator) ||
+         if ((terminator > 0 && *ptr++ != (pcre_uchar)terminator) ||
              *ptr++ != CHAR_RIGHT_PARENTHESIS)
            {
            ptr--;      /* Error offset */
-Line 5845 
 for (;; ptr++)
+Line 5892 
 for (;; ptr++)
            code[1+LINK_SIZE]++;
            }
-         /* If terminator == 0 it means that the name followed directly after
+         /* If terminator == CHAR_NULL it means that the name followed directly
-         the opening parenthesis [e.g. (?(abc)...] and in this case there are
+         after the opening parenthesis [e.g. (?(abc)...] and in this case there
-         some further alternatives to try. For the cases where terminator != 0
+         are some further alternatives to try. For the cases where terminator !=
-         [things like (?(<name>... or (?('name')... or (?(R&name)... ] we have
+[things like (?(<name>... or (?('name')... or (?(R&name)... ] we have
          now checked all the possibilities, so give an error. */
-         else if (terminator != 0)
+         else if (terminator != CHAR_NULL)
            {
            *errorcodeptr = ERR15;
            goto FAILED;
-Line 6020 
 for (;; ptr++)
+Line 6067 
 for (;; ptr++)
            if (lengthptr != NULL)
              {
-             if (*ptr != terminator)
+             if (*ptr != (pcre_uchar)terminator)
                {
                *errorcodeptr = ERR42;
                goto FAILED;
-Line 6162 
 for (;; ptr++)
+Line 6209 
 for (;; ptr++)
              *errorcodeptr = ERR62;
              goto FAILED;
              }
-           if (*ptr != terminator)
+           if (*ptr != (pcre_uchar)terminator)
              {
              *errorcodeptr = ERR42;
              goto FAILED;
-Line 6268 
 for (;; ptr++)
+Line 6315 
 for (;; ptr++)
            while(IS_DIGIT(*ptr))
              recno = recno * 10 + *ptr++ - CHAR_0;
-           if (*ptr != terminator)
+           if (*ptr != (pcre_uchar)terminator)
              {
              *errorcodeptr = ERR29;
              goto FAILED;
-Line 6372 
 for (;; ptr++)
+Line 6419 
 for (;; ptr++)
          /* Can't determine a first byte now */
-         if (firstchar == REQ_UNSET) firstchar = REQ_NONE;
+         if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
          continue;
-Line 6506 
 for (;; ptr++)
+Line 6553 
 for (;; ptr++)
           cond_depth +
             ((bravalue == OP_COND)?1:0),   /* Depth of condition subpatterns */
           &subfirstchar,                   /* For possible first char */
+          &subfirstcharflags,
           &subreqchar,                     /* For possible last char */
+          &subreqcharflags,
           bcptr,                           /* Current branch chain */
           cd,                              /* Tables block */
           (lengthptr == NULL)? NULL :      /* Actual compile phase */
-Line 6567 
 for (;; ptr++)
+Line 6616 
 for (;; ptr++)
            *errorcodeptr = ERR27;
            goto FAILED;
            }
-         if (condcount == 1) subfirstchar = subreqchar = REQ_NONE;
+         if (condcount == 1) subfirstcharflags = subreqcharflags = REQ_NONE;
          }
        }
-Line 6616 
 for (;; ptr++)
+Line 6665 
 for (;; ptr++)
      back off. */
      zeroreqchar = reqchar;
+     zeroreqcharflags = reqcharflags;
      zerofirstchar = firstchar;
+     zerofirstcharflags = firstcharflags;
      groupsetfirstchar = FALSE;
      if (bravalue >= OP_ONCE)
-Line 6627 
 for (;; ptr++)
+Line 6678 
 for (;; ptr++)
        no firstchar, set "none" for the whole branch. In both cases, a zero
        repeat forces firstchar to "none". */
-       if (firstchar == REQ_UNSET)
+       if (firstcharflags == REQ_UNSET)
          {
-         if (subfirstchar >= 0)
+         if (subfirstcharflags >= 0)
            {
            firstchar = subfirstchar;
+           firstcharflags = subfirstcharflags;
            groupsetfirstchar = TRUE;
            }
-         else firstchar = REQ_NONE;
+         else firstcharflags = REQ_NONE;
-         zerofirstchar = REQ_NONE;
+         zerofirstcharflags = REQ_NONE;
          }
        /* If firstchar was previously set, convert the subpattern's firstchar
        into reqchar if there wasn't one, using the vary flag that was in
        existence beforehand. */
-       else if (subfirstchar >= 0 && subreqchar < 0)
+       else if (subfirstcharflags >= 0 && subreqcharflags < 0)
-         subreqchar = subfirstchar | tempreqvary;
+         {
+         subreqchar = subfirstchar;
+         subreqcharflags = subfirstcharflags | tempreqvary;
+         }
        /* If the subpattern set a required byte (or set a first byte that isn't
        really the first byte - see above), set it. */
-       if (subreqchar >= 0) reqchar = subreqchar;
+       if (subreqcharflags >= 0)
+         {
+         reqchar = subreqchar;
+         reqcharflags = subreqcharflags;
+         }
        }
      /* For a forward assertion, we take the reqchar, if set. This can be
-Line 6659 
 for (;; ptr++)
+Line 6718 
 for (;; ptr++)
      of a firstchar. This is overcome by a scan at the end if there's no
      firstchar, looking for an asserted first char. */
-     else if (bravalue == OP_ASSERT && subreqchar >= 0) reqchar = subreqchar;
+     else if (bravalue == OP_ASSERT && subreqcharflags >= 0)
+       {
+       reqchar = subreqchar;
+       reqcharflags = subreqcharflags;
+       }
      break;     /* End of processing '(' */
-Line 6667 
 for (;; ptr++)
+Line 6730 
 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
+     are negative the reference number. Only back references and those types
      that consume a character may be repeated. We can test for values between
      ESC_b and ESC_Z for the latter; this may have to change if any new ones are
      ever created. */
-Line 6695 
 for (;; ptr++)
+Line 6758 
 for (;; ptr++)
        /* For metasequences that actually match a character, we disable the
        setting of a first character if it hasn't already been set. */
-       if (firstchar == REQ_UNSET && escape > ESC_b && escape < ESC_Z)
+       if (firstcharflags == REQ_UNSET && escape > ESC_b && escape < ESC_Z)
-         firstchar = REQ_NONE;
+         firstcharflags = REQ_NONE;
        /* Set values to reset to if this is followed by a zero repeat. */
        zerofirstchar = firstchar;
+       zerofirstcharflags = firstcharflags;
        zeroreqchar = reqchar;
+       zeroreqcharflags = reqcharflags;
        /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n'
        is a subroutine call by number (Oniguruma syntax). In fact, the value
        ESC_g is returned only for these cases. So we don't need to check for <
        or ' if the value is ESC_g. For the Perl syntax \g{n} the value is
-       ESC_REF+n, and for the Perl syntax \g{name} the result is ESC_k (as
+       -n, and for the Perl syntax \g{name} the result is ESC_k (as
        that is a synonym for a named back reference). */
        if (escape == ESC_g)
-Line 6730 
 for (;; ptr++)
+Line 6795 
 for (;; ptr++)
          if (ptr[1] != CHAR_PLUS && ptr[1] != CHAR_MINUS)
            {
            BOOL is_a_number = TRUE;
-           for (p = ptr + 1; *p != 0 && *p != terminator; p++)
+           for (p = ptr + 1; *p != CHAR_NULL && *p != (pcre_uchar)terminator; p++)
              {
              if (!MAX_255(*p)) { is_a_number = FALSE; break; }
              if ((cd->ctypes[*p] & ctype_digit) == 0) is_a_number = FALSE;
              if ((cd->ctypes[*p] & ctype_word) == 0) break;
              }
-           if (*p != terminator)
+           if (*p != (pcre_uchar)terminator)
              {
              *errorcodeptr = ERR57;
              break;
-Line 6754 
 for (;; ptr++)
+Line 6819 
 for (;; ptr++)
          p = ptr + 2;
          while (IS_DIGIT(*p)) p++;
-         if (*p != terminator)
+         if (*p != (pcre_uchar)terminator)
            {
            *errorcodeptr = ERR57;
            break;
-Line 6785 
 for (;; ptr++)
+Line 6850 
 for (;; ptr++)
        not set to cope with cases like (?=(\w+))\1: which would otherwise set
        ':' later. */
-       if (escape >= ESC_REF)
+       if (escape < 0)
          {
          open_capitem *oc;
-         recno = escape - ESC_REF;
+         recno = -escape;
          HANDLE_REFERENCE:    /* Come here from named backref handling */
-         if (firstchar == REQ_UNSET) firstchar = REQ_NONE;
+         if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
          previous = code;
          *code++ = ((options & PCRE_CASELESS) != 0)? OP_REFI : OP_REF;
          PUT2INC(code, 0, recno);
-Line 6818 
 for (;; ptr++)
+Line 6883 
 for (;; ptr++)
        else if (escape == ESC_P || escape == ESC_p)
          {
          BOOL negated;
-         int pdata;
+         unsigned int ptype = 0, pdata = 0;
-         int ptype = get_ucp(&ptr, &negated, &pdata, errorcodeptr);
+         if (!get_ucp(&ptr, &negated, &ptype, &pdata, errorcodeptr))
-         if (ptype < 0) goto FAILED;
+           goto FAILED;
          previous = code;
          *code++ = ((escape == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
          *code++ = ptype;
-Line 6894 
 for (;; ptr++)
+Line 6959 
 for (;; ptr++)
      mclength = 1;
      mcbuffer[0] = c;
- #if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+ #ifdef SUPPORT_UTF
      if (utf && HAS_EXTRALEN(c))
        ACROSSCHAR(TRUE, ptr[1], mcbuffer[mclength++] = *(++ptr));
  #endif
-Line 6918 
 for (;; ptr++)
+Line 6983 
 for (;; ptr++)
          *code++ = OP_PROP;
          *code++ = PT_CLIST;
          *code++ = c;
-         if (firstchar == REQ_UNSET) firstchar = zerofirstchar = REQ_NONE;
+         if (firstcharflags == REQ_UNSET) firstcharflags = zerofirstcharflags = REQ_NONE;
          break;
          }
        }
-Line 6939 
 for (;; ptr++)
+Line 7004 
 for (;; ptr++)
      Otherwise, leave the firstchar value alone, and don't change it on a zero
      repeat. */
-     if (firstchar == REQ_UNSET)
+     if (firstcharflags == REQ_UNSET)
        {
-       zerofirstchar = REQ_NONE;
+       zerofirstcharflags = REQ_NONE;
        zeroreqchar = reqchar;
+       zeroreqcharflags = reqcharflags;
        /* If the character is more than one byte long, we can set firstchar
        only if it is not to be matched caselessly. */
-Line 6950 
 for (;; ptr++)
+Line 7016 
 for (;; ptr++)
        if (mclength == 1 || req_caseopt == 0)
          {
          firstchar = mcbuffer[0] | req_caseopt;
-         if (mclength != 1) reqchar = code[-1] | cd->req_varyopt;
+         firstchar = mcbuffer[0];
+         firstcharflags = req_caseopt;
+         if (mclength != 1)
+           {
+           reqchar = code[-1];
+           reqcharflags = cd->req_varyopt;
+           }
          }
-       else firstchar = reqchar = REQ_NONE;
+       else firstcharflags = reqcharflags = REQ_NONE;
        }
      /* firstchar was previously set; we can set reqchar only if the length is
-Line 6961 
 for (;; ptr++)
+Line 7034 
 for (;; ptr++)
      else
        {
        zerofirstchar = firstchar;
+       zerofirstcharflags = firstcharflags;
        zeroreqchar = reqchar;
+       zeroreqcharflags = reqcharflags;
        if (mclength == 1 || req_caseopt == 0)
-         reqchar = code[-1] | req_caseopt | cd->req_varyopt;
+         {
+         reqchar = code[-1];
+         reqcharflags = req_caseopt | cd->req_varyopt;
+         }
        }
      break;            /* End of literal character handling */
-Line 6982 
 return FALSE;
+Line 7060 
 return FALSE;
  /*************************************************
  *     Compile sequence of alternatives           *
  *************************************************/
-Line 7003 
 Arguments:
+Line 7080 
 Arguments:
    reset_bracount TRUE to reset the count for each branch
    skipbytes      skip this many bytes at start (for brackets and OP_COND)
    cond_depth     depth of nesting for conditional subpatterns
-   firstcharptr   place to put the first required character, or a negative number
+   firstcharptr    place to put the first required character
-   reqcharptr     place to put the last required character, or a negative number
+   firstcharflagsptr place to put the first character flags, or a negative number
+   reqcharptr     place to put the last required character
+   reqcharflagsptr place to put the last required character flags, or a negative number
    bcptr          pointer to the chain of currently open branches
    cd             points to the data block with tables pointers etc.
    lengthptr      NULL during the real compile phase
-Line 7016 
 Returns:         TRUE on success
+Line 7095 
 Returns:         TRUE on success
  static BOOL
  compile_regex(int options, pcre_uchar **codeptr, const pcre_uchar **ptrptr,
    int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,
-   int cond_depth, pcre_int32 *firstcharptr, pcre_int32 *reqcharptr,
+   int cond_depth,
+   pcre_uint32 *firstcharptr, pcre_int32 *firstcharflagsptr,
+   pcre_uint32 *reqcharptr, pcre_int32 *reqcharflagsptr,
    branch_chain *bcptr, compile_data *cd, int *lengthptr)
  {
  const pcre_uchar *ptr = *ptrptr;
-Line 7026 
 pcre_uchar *start_bracket = code;
+Line 7107 
 pcre_uchar *start_bracket = code;
  pcre_uchar *reverse_count = NULL;
  open_capitem capitem;
  int capnumber = 0;
- pcre_int32 firstchar, reqchar;
+ pcre_uint32 firstchar, reqchar;
- pcre_int32 branchfirstchar, branchreqchar;
+ pcre_int32 firstcharflags, reqcharflags;
+ pcre_uint32 branchfirstchar, branchreqchar;
+ pcre_int32 branchfirstcharflags, branchreqcharflags;
  int length;
- int orig_bracount;
+ unsigned int orig_bracount;
- int max_bracount;
+ unsigned int max_bracount;
  branch_chain bc;
  bc.outer = bcptr;
  bc.current_branch = code;
- firstchar = reqchar = REQ_UNSET;
+ firstchar = reqchar = 0;
+ firstcharflags = reqcharflags = REQ_UNSET;
  /* Accumulate the length for use in the pre-compile phase. Start with the
  length of the BRA and KET and any extra bytes that are required at the
-Line 7096 
 for (;;)
+Line 7180 
 for (;;)
    into the length. */
    if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstchar,
-         &branchreqchar, &bc, cond_depth, cd,
+         &branchfirstcharflags, &branchreqchar, &branchreqcharflags, &bc,
-         (lengthptr == NULL)? NULL : &length))
+         cond_depth, cd, (lengthptr == NULL)? NULL : &length))
      {
      *ptrptr = ptr;
      return FALSE;
-Line 7118 
 for (;;)
+Line 7202 
 for (;;)
      if (*last_branch != OP_ALT)
        {
        firstchar = branchfirstchar;
+       firstcharflags = branchfirstcharflags;
        reqchar = branchreqchar;
+       reqcharflags = branchreqcharflags;
        }
      /* If this is not the first branch, the first char and reqchar have to
-Line 7132 
 for (;;)
+Line 7218 
 for (;;)
        we have to abandon the firstchar for the regex, but if there was
        previously no reqchar, it takes on the value of the old firstchar. */
-       if (firstchar >= 0 && firstchar != branchfirstchar)
+       if (firstcharflags >= 0 &&
+           (firstcharflags != branchfirstcharflags || firstchar != branchfirstchar))
          {
-         if (reqchar < 0) reqchar = firstchar;
+         if (reqcharflags < 0)
-         firstchar = REQ_NONE;
+           {
+           reqchar = firstchar;
+           reqcharflags = firstcharflags;
+           }
+         firstcharflags = REQ_NONE;
          }
        /* If we (now or from before) have no firstchar, a firstchar from the
        branch becomes a reqchar if there isn't a branch reqchar. */
-       if (firstchar < 0 && branchfirstchar >= 0 && branchreqchar < 0)
+       if (firstcharflags < 0 && branchfirstcharflags >= 0 && branchreqcharflags < 0)
-           branchreqchar = branchfirstchar;
+         {
+         branchreqchar = branchfirstchar;
+         branchreqcharflags = branchfirstcharflags;
+         }
        /* Now ensure that the reqchars match */
-       if ((reqchar & ~REQ_VARY) != (branchreqchar & ~REQ_VARY))
+       if (((reqcharflags & ~REQ_VARY) != (branchreqcharflags & ~REQ_VARY)) ||
-         reqchar = REQ_NONE;
+           reqchar != branchreqchar)
-       else reqchar |= branchreqchar;   /* To "or" REQ_VARY */
+         reqcharflags = REQ_NONE;
+       else
+         {
+         reqchar = branchreqchar;
+         reqcharflags |= branchreqcharflags; /* To "or" REQ_VARY */
+         }
        }
      /* If lookbehind, check that this branch matches a fixed-length string, and
-Line 7244 
 for (;;)
+Line 7343 
 for (;;)
      *codeptr = code;
      *ptrptr = ptr;
      *firstcharptr = firstchar;
+     *firstcharflagsptr = firstcharflags;
      *reqcharptr = reqchar;
+     *reqcharflagsptr = reqcharflags;
      if (lengthptr != NULL)
        {
        if (OFLOW_MAX - *lengthptr < length)
-Line 7531 
 we return that char, otherwise -1.
+Line 7632 
 we return that char, otherwise -1.
  Arguments:
    code       points to start of expression (the bracket)
+   flags       points to the first char flags, or to REQ_NONE
    inassert   TRUE if in an assertion
- Returns:     -1 or the fixed first char
+ Returns:     the fixed first char, or 0 with REQ_NONE in flags
  */
- static int
+ static pcre_uint32
- find_firstassertedchar(const pcre_uchar *code, BOOL inassert)
+ find_firstassertedchar(const pcre_uchar *code, pcre_int32 *flags,
+   BOOL inassert)
  {
- register int c = -1;
+ register pcre_uint32 c = 0;
+ int cflags = REQ_NONE;
+ *flags = REQ_NONE;
  do {
-    int d;
+    pcre_uint32 d;
+    int dflags;
     int xl = (*code == OP_CBRA || *code == OP_SCBRA ||
               *code == OP_CBRAPOS || *code == OP_SCBRAPOS)? IMM2_SIZE:0;
     const pcre_uchar *scode = first_significant_code(code + 1+LINK_SIZE + xl,
       TRUE);
-    register int op = *scode;
+    register pcre_uchar op = *scode;
     switch(op)
       {
       default:
-      return -1;
+      return 0;
       case OP_BRA:
       case OP_BRAPOS:
-Line 7563 
 do {
+Line 7670 
 do {
       case OP_ONCE:
       case OP_ONCE_NC:
       case OP_COND:
-      if ((d = find_firstassertedchar(scode, op == OP_ASSERT)) < 0)
+      d = find_firstassertedchar(scode, &dflags, op == OP_ASSERT);
-        return -1;
+      if (dflags < 0)
-      if (c < 0) c = d; else if (c != d) return -1;
+        return 0;
+      if (cflags < 0) { c = d; cflags = dflags; } else if (c != d || cflags != dflags) return 0;
       break;
       case OP_EXACT:
-Line 7576 
 do {
+Line 7684 
 do {
       case OP_PLUS:
       case OP_MINPLUS:
       case OP_POSPLUS:
-      if (!inassert) return -1;
+      if (!inassert) return 0;
-      if (c < 0) c = scode[1];
+      if (cflags < 0) { c = scode[1]; cflags = 0; }
-        else if (c != scode[1]) return -1;
+        else if (c != scode[1]) return 0;
       break;
       case OP_EXACTI:
-Line 7589 
 do {
+Line 7697 
 do {
       case OP_PLUSI:
       case OP_MINPLUSI:
       case OP_POSPLUSI:
-      if (!inassert) return -1;
+      if (!inassert) return 0;
-      if (c < 0) c = scode[1] | REQ_CASELESS;
+      if (cflags < 0) { c = scode[1]; cflags = REQ_CASELESS; }
-        else if (c != scode[1]) return -1;
+        else if (c != scode[1]) return 0;
       break;
       }
     code += GET(code, 1);
     }
  while (*code == OP_ALT);
+ *flags = cflags;
  return c;
  }
-Line 7665 
 pcre32_compile2(PCRE_SPTR32 pattern, int
+Line 7775 
 pcre32_compile2(PCRE_SPTR32 pattern, int
  {
  REAL_PCRE *re;
  int length = 1;  /* For final END opcode */
- pcre_int32 firstchar, reqchar;
+ pcre_uint32 firstchar, reqchar;
+ pcre_int32 firstcharflags, reqcharflags;
  int newline;
  int errorcode = 0;
  int skipatstart = 0;
-Line 7737 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
+Line 7848 
 while (ptr[skipatstart] == CHAR_LEFT_PAR
    {
    int newnl = 0;
    int newbsr = 0;
+ /* For completeness and backward compatibility, (*UTFn) is supported in the
+ relevant libraries, but (*UTF) is generic and always supported. Note that
+ PCRE_UTF8 == PCRE_UTF16 == PCRE_UTF32. */
  #ifdef COMPILE_PCRE8
-   if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 5) == 0)
+   if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF8_RIGHTPAR, 5) == 0)
      { skipatstart += 7; options |= PCRE_UTF8; continue; }
  #endif
  #ifdef COMPILE_PCRE16
-   if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 6) == 0)
+   if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF16_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)
+   if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF32_RIGHTPAR, 6) == 0)
      { skipatstart += 8; options |= PCRE_UTF32; continue; }
  #endif
+   else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 4) == 0)
+     { skipatstart += 6; options |= PCRE_UTF8; continue; }
    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 7915 
 ptr += skipatstart;
+Line 8033 
 ptr += skipatstart;
  code = cworkspace;
  *code = OP_BRA;
  (void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,
-   FALSE, 0, 0, &firstchar, &reqchar, NULL, cd, &length);
+   FALSE, 0, 0, &firstchar, &firstcharflags, &reqchar, &reqcharflags, NULL,
+   cd, &length);
  if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;
  DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,
-Line 7993 
 ptr = (const pcre_uchar *)pattern + skip
+Line 8112 
 ptr = (const pcre_uchar *)pattern + skip
  code = (pcre_uchar *)codestart;
  *code = OP_BRA;
  (void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,
-   &firstchar, &reqchar, NULL, cd, NULL);
+   &firstchar, &firstcharflags, &reqchar, &reqcharflags, NULL, cd, NULL);
  re->top_bracket = cd->bracount;
  re->top_backref = cd->top_backref;
  re->max_lookbehind = cd->max_lookbehind;
  re->flags = cd->external_flags | PCRE_MODE;
- if (cd->had_accept) reqchar = REQ_NONE;   /* Must disable after (*ACCEPT) */
+ if (cd->had_accept)
+   {
+   reqchar = 0;              /* Must disable after (*ACCEPT) */
+   reqcharflags = REQ_NONE;
+   }
  /* If not reached end of pattern on success, there's an excess bracket. */
- if (errorcode == 0 && *ptr != 0) errorcode = ERR22;
+ if (errorcode == 0 && *ptr != CHAR_NULL) errorcode = ERR22;
  /* Fill in the terminating state and check for disastrous overflow, but
  if debugging, leave the test till after things are printed out. */
-Line 8014 
 if debugging, leave the test till after
+Line 8137 
 if debugging, leave the test till after
  if (code - codestart > length) errorcode = ERR23;
  #endif
+ #ifdef SUPPORT_VALGRIND
+ /* If the estimated length exceeds the really used length, mark the extra
+ allocated memory as unadressable, so that any out-of-bound reads can be
+ detected. */
+ VALGRIND_MAKE_MEM_NOACCESS(code, (length - (code - codestart)) * sizeof(pcre_uchar));
+ #endif
  /* Fill in any forward references that are required. There may be repeated
  references; optimize for them, as searching a large regex takes time. */
-Line 8049 
 if (errorcode == 0 && re->top_backref >
+Line 8179 
 if (errorcode == 0 && re->top_backref >
  /* If there were any lookbehind assertions that contained OP_RECURSE
  (recursions or subroutine calls), a flag is set for them to be checked here,
- because they may contain forward references. Actual recursions can't be fixed
+ because they may contain forward references. Actual recursions cannot be fixed
  length, but subroutine calls can. It is done like this so that those without
  OP_RECURSE that are not fixed length get a diagnosic with a useful offset. The
  exceptional ones forgo this. We scan the pattern to check that they are fixed
-Line 8120 
 if ((re->options & PCRE_ANCHORED) == 0)
+Line 8250 
 if ((re->options & PCRE_ANCHORED) == 0)
    if (is_anchored(codestart, 0, cd, 0)) re->options |= PCRE_ANCHORED;
    else
      {
-     if (firstchar < 0)
+     if (firstcharflags < 0)
-       firstchar = find_firstassertedchar(codestart, FALSE);
+       firstchar = find_firstassertedchar(codestart, &firstcharflags, FALSE);
-     if (firstchar >= 0)   /* Remove caseless flag for non-caseable chars */
+     if (firstcharflags >= 0)   /* Remove caseless flag for non-caseable chars */
        {
  #if defined COMPILE_PCRE8
        re->first_char = firstchar & 0xff;
  #elif defined COMPILE_PCRE16
        re->first_char = firstchar & 0xffff;
  #elif defined COMPILE_PCRE32
-       re->first_char = firstchar & ~REQ_MASK;
+       re->first_char = firstchar;
  #endif
-       if ((firstchar & REQ_CASELESS) != 0)
+       if ((firstcharflags & REQ_CASELESS) != 0)
          {
  #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
          /* We ignore non-ASCII first chars in 8 bit mode. */
-Line 8163 
 if ((re->options & PCRE_ANCHORED) == 0)
+Line 8293 
 if ((re->options & PCRE_ANCHORED) == 0)
  variable length item in the regex. Remove the caseless flag for non-caseable
  bytes. */
- if (reqchar >= 0 &&
+ if (reqcharflags >= 0 &&
-      ((re->options & PCRE_ANCHORED) == 0 || (reqchar & REQ_VARY) != 0))
+      ((re->options & PCRE_ANCHORED) == 0 || (reqcharflags & REQ_VARY) != 0))
    {
  #if defined COMPILE_PCRE8
    re->req_char = reqchar & 0xff;
  #elif defined COMPILE_PCRE16
    re->req_char = reqchar & 0xffff;
  #elif defined COMPILE_PCRE32
-   re->req_char = reqchar & ~REQ_MASK;
+   re->req_char = reqchar;
  #endif
-   if ((reqchar & REQ_CASELESS) != 0)
+   if ((reqcharflags & REQ_CASELESS) != 0)
      {
  #if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
      /* We ignore non-ASCII first chars in 8 bit mode. */

 Legend:



Removed from v.1059
 


changed lines


 
Added in v.1219
 Legend:



Removed from v.1059
 


changed lines


 
Added in v.1219
-Removed from v.1059
+Added in v.1219

	ViewVC Help
Powered by ViewVC 1.1.5