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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 168 by ph10,
Tue May 29 15:18:18 2007 UTC
+revision 206 by ph10,
Fri Aug  3 14:53:04 2007 UTC
 Line 42 
 POSSIBILITY OF SUCH DAMAGE.
  supporting internal functions that are not used by other modules. */
+ #ifdef HAVE_CONFIG_H
+ #include <config.h>
+ #endif
  #define NLBLOCK cd             /* Block containing newline information */
  #define PSSTART start_pattern  /* Field containing processed string start */
  #define PSEND   end_pattern    /* Field containing processed string end */
  #include "pcre_internal.h"
-Line 58 
 used by pcretest. DEBUG is not defined w
+Line 61 
 used by pcretest. DEBUG is not defined w
  #endif
+ /* Macro for setting individual bits in class bitmaps. */
+ #define SETBIT(a,b) a[b/8] |= (1 << (b%8))
+ /* 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
+ INT_MAX to allow for adding in group terminating bytes, so that we don't have
+ to check them every time. */
+ #define OFLOW_MAX (INT_MAX - 20)
  /*************************************************
  *      Code parameters and static tables         *
  *************************************************/
-Line 87 
 static const short int escapes[] = {
+Line 102 
 static const short int escapes[] = {
 ,      0,      0,      0,      0,      0,      0,      0,   /* 0 - 7 */
 ,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */
     '@', -ESC_A, -ESC_B, -ESC_C, -ESC_D, -ESC_E,      0, -ESC_G,   /* @ - G */
-,      0,      0, -ESC_K,      0,      0,      0,      0,   /* H - O */
+ -ESC_H,      0,      0, -ESC_K,      0,      0,      0,      0,   /* H - O */
- -ESC_P, -ESC_Q, -ESC_R, -ESC_S,      0,      0,      0, -ESC_W,   /* P - W */
+ -ESC_P, -ESC_Q, -ESC_R, -ESC_S,      0,      0, -ESC_V, -ESC_W,   /* P - W */
  -ESC_X,      0, -ESC_Z,    '[',   '\\',    ']',    '^',    '_',   /* X - _ */
     '`',      7, -ESC_b,      0, -ESC_d,  ESC_e,  ESC_f,      0,   /* ` - g */
-,      0,      0, -ESC_k,      0,      0,  ESC_n,      0,   /* h - o */
+ -ESC_h,      0,      0, -ESC_k,      0,      0,  ESC_n,      0,   /* h - o */
- -ESC_p,      0,  ESC_r, -ESC_s,  ESC_tee,    0,      0, -ESC_w,   /* p - w */
+ -ESC_p,      0,  ESC_r, -ESC_s,  ESC_tee,    0, -ESC_v, -ESC_w,   /* p - w */
 ,      0, -ESC_z                                            /* x - z */
  };
-Line 106 
 static const short int escapes[] = {
+Line 121 
 static const short int escapes[] = {
  /*  70 */     0,     0,      0,       0,      0,     0,      0,      0,
  /*  78 */     0,   '`',    ':',     '#',    '@',  '\'',    '=',    '"',
  /*  80 */     0,     7, -ESC_b,       0, -ESC_d, ESC_e,  ESC_f,      0,
- /*  88 */     0,     0,      0,     '{',      0,     0,      0,      0,
+ /*  88 */-ESC_h,     0,      0,     '{',      0,     0,      0,      0,
  /*  90 */     0,     0, -ESC_k,     'l',      0, ESC_n,      0, -ESC_p,
  /*  98 */     0, ESC_r,      0,     '}',      0,     0,      0,      0,
- /*  A0 */     0,   '~', -ESC_s, ESC_tee,      0,     0, -ESC_w,      0,
+ /*  A0 */     0,   '~', -ESC_s, ESC_tee,      0,-ESC_v, -ESC_w,      0,
  /*  A8 */     0,-ESC_z,      0,       0,      0,   '[',      0,      0,
  /*  B0 */     0,     0,      0,       0,      0,     0,      0,      0,
  /*  B8 */     0,     0,      0,       0,      0,   ']',    '=',    '-',
  /*  C0 */   '{',-ESC_A, -ESC_B,  -ESC_C, -ESC_D,-ESC_E,      0, -ESC_G,
- /*  C8 */     0,     0,      0,       0,      0,     0,      0,      0,
+ /*  C8 */-ESC_H,     0,      0,       0,      0,     0,      0,      0,
- /*  D0 */   '}',     0,      0,       0,      0,     0,      0, -ESC_P,
+ /*  D0 */   '}',     0, -ESC_K,       0,      0,     0,      0, -ESC_P,
  /*  D8 */-ESC_Q,-ESC_R,      0,       0,      0,     0,      0,      0,
- /*  E0 */  '\\',     0, -ESC_S,       0,      0,     0, -ESC_W, -ESC_X,
+ /*  E0 */  '\\',     0, -ESC_S,       0,      0,-ESC_V, -ESC_W, -ESC_X,
  /*  E8 */     0,-ESC_Z,      0,       0,      0,     0,      0,      0,
  /*  F0 */     0,     0,      0,       0,      0,     0,      0,      0,
  /*  F8 */     0,     0,      0,       0,      0,     0,      0,      0
-Line 198 
 static const char *error_texts[] = {
+Line 213 
 static const char *error_texts[] = {
    "missing ) after comment",
    "parentheses nested too deeply",  /** DEAD **/
    /* 20 */
-   "regular expression too large",
+   "regular expression is too large",
    "failed to get memory",
    "unmatched parentheses",
    "internal error: code overflow",
-Line 234 
 static const char *error_texts[] = {
+Line 249 
 static const char *error_texts[] = {
    "subpattern name is too long (maximum " XSTRING(MAX_NAME_SIZE) " characters)",
    "too many named subpatterns (maximum " XSTRING(MAX_NAME_COUNT) ")",
    /* 50 */
-   "repeated subpattern is too long",
+   "repeated subpattern is too long",    /** DEAD **/
    "octal value is greater than \\377 (not in UTF-8 mode)",
    "internal error: overran compiling workspace",
    "internal error: previously-checked referenced subpattern not found",
-Line 242 
 static const char *error_texts[] = {
+Line 257 
 static const char *error_texts[] = {
    /* 55 */
    "repeating a DEFINE group is not allowed",
    "inconsistent NEWLINE options",
-   "\\g is not followed by an (optionally braced) non-zero number",
+   "\\g is not followed by a braced name or an optionally braced non-zero number",
    "(?+ or (?- or (?(+ or (?(- must be followed by a non-zero number"
  };
-Line 374 
 static const unsigned char ebcdic_charta
+Line 389 
 static const unsigned char ebcdic_charta
  /* Definition to allow mutual recursion */
  static BOOL
-   compile_regex(int, int, uschar **, const uschar **, int *, BOOL, int, int *,
+   compile_regex(int, int, uschar **, const uschar **, int *, BOOL, BOOL, int,
-     int *, branch_chain *, compile_data *, int *);
+     int *, int *, branch_chain *, compile_data *, int *);
-Line 453 
 else
+Line 468 
 else
      /* \g must be followed by a number, either plain or braced. If positive, it
      is an absolute backreference. If negative, it is a relative backreference.
-     This is a Perl 5.10 feature. */
+     This is a Perl 5.10 feature. Perl 5.10 also supports \g{name} as a
+     reference to a named group. This is part of Perl's movement towards a
+     unified syntax for back references. As this is synonymous with \k{name}, we
+     fudge it up by pretending it really was \k. */
      case 'g':
      if (ptr[1] == '{')
        {
+       const uschar *p;
+       for (p = ptr+2; *p != 0 && *p != '}'; p++)
+         if (*p != '-' && (digitab[*p] & ctype_digit) == 0) break;
+       if (*p != 0 && *p != '}')
+         {
+         c = -ESC_k;
+         break;
+         }
        braced = TRUE;
        ptr++;
        }
-Line 685 
 if (c == '{')
+Line 711 
 if (c == '{')
      *negptr = TRUE;
      ptr++;
      }
-   for (i = 0; i < sizeof(name) - 1; i++)
+   for (i = 0; i < (int)sizeof(name) - 1; i++)
      {
      c = *(++ptr);
      if (c == 0) goto ERROR_RETURN;
-Line 1371 
 for (code = first_significant_code(code
+Line 1397 
 for (code = first_significant_code(code
    c = *code;
-   if (c == OP_BRA || c == OP_CBRA || c == OP_ONCE)
+   /* Groups with zero repeats can of course be empty; skip them. */
+   if (c == OP_BRAZERO || c == OP_BRAMINZERO)
+     {
+     code += _pcre_OP_lengths[c];
+     do code += GET(code, 1); while (*code == OP_ALT);
+     c = *code;
+     continue;
+     }
+   /* For other groups, scan the branches. */
+   if (c == OP_BRA || c == OP_CBRA || c == OP_ONCE || c == OP_COND)
      {
      BOOL empty_branch;
      if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */
-Line 1387 
 for (code = first_significant_code(code
+Line 1425 
 for (code = first_significant_code(code
        }
      while (*code == OP_ALT);
      if (!empty_branch) return FALSE;   /* All branches are non-empty */
+     c = *code;
-     /* Move past the KET and fudge things so that the increment in the "for"
-     above has no effect. */
-     c = OP_END;
-     code += 1 + LINK_SIZE - _pcre_OP_lengths[c];
      continue;
      }
-Line 1926 
 if (next >= 0) switch(op_code)
+Line 1959 
 if (next >= 0) switch(op_code)
    case OP_NOT_WORDCHAR:
    return next <= 127 && (cd->ctypes[next] & ctype_word) != 0;
+   case OP_HSPACE:
+   case OP_NOT_HSPACE:
+   switch(next)
+     {
+     case 0x09:
+     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 op_code != OP_HSPACE;
+     default:
+     return op_code == OP_HSPACE;
+     }
+   case OP_VSPACE:
+   case OP_NOT_VSPACE:
+   switch(next)
+     {
+     case 0x0a:
+     case 0x0b:
+     case 0x0c:
+     case 0x0d:
+     case 0x85:
+     case 0x2028:
+     case 0x2029:
+     return op_code != OP_VSPACE;
+     default:
+     return op_code == OP_VSPACE;
+     }
    default:
    return FALSE;
    }
-Line 1960 
 switch(op_code)
+Line 2037 
 switch(op_code)
      case ESC_W:
      return item <= 127 && (cd->ctypes[item] & ctype_word) != 0;
+     case ESC_h:
+     case ESC_H:
+     switch(item)
+       {
+       case 0x09:
+       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;
+       }
+     case ESC_v:
+     case ESC_V:
+     switch(item)
+       {
+       case 0x0a:
+       case 0x0b:
+       case 0x0c:
+       case 0x0d:
+       case 0x85:
+       case 0x2028:
+       case 0x2029:
+       return -next != ESC_v;
+       default:
+       return -next == ESC_v;
+       }
      default:
      return FALSE;
      }
    case OP_DIGIT:
-   return next == -ESC_D || next == -ESC_s || next == -ESC_W;
+   return next == -ESC_D || next == -ESC_s || next == -ESC_W ||
+          next == -ESC_h || next == -ESC_v;
    case OP_NOT_DIGIT:
    return next == -ESC_d;
-Line 1974 
 switch(op_code)
+Line 2096 
 switch(op_code)
    return next == -ESC_S || next == -ESC_d || next == -ESC_w;
    case OP_NOT_WHITESPACE:
-   return next == -ESC_s;
+   return next == -ESC_s || next == -ESC_h || next == -ESC_v;
+   case OP_HSPACE:
+   return next == -ESC_S || next == -ESC_H || next == -ESC_d || next == -ESC_w;
+   case OP_NOT_HSPACE:
+   return next == -ESC_h;
+   /* Can't have \S in here because VT matches \S (Perl anomaly) */
+   case OP_VSPACE:
+   return next == -ESC_V || next == -ESC_d || next == -ESC_w;
+   case OP_NOT_VSPACE:
+   return next == -ESC_v;
    case OP_WORDCHAR:
-   return next == -ESC_W || next == -ESC_s;
+   return next == -ESC_W || next == -ESC_s || next == -ESC_h || next == -ESC_v;
    case OP_NOT_WORDCHAR:
    return next == -ESC_w || next == -ESC_d;
-Line 2092 
 for (;; ptr++)
+Line 2227 
 for (;; ptr++)
    BOOL possessive_quantifier;
    BOOL is_quantifier;
    BOOL is_recurse;
+   BOOL reset_bracount;
    int class_charcount;
    int class_lastchar;
    int newoptions;
    int recno;
    int refsign;
    int skipbytes;
    int subreqbyte;
    int subfirstbyte;
-Line 2129 
 for (;; ptr++)
+Line 2265 
 for (;; ptr++)
      */
      if (code < last_code) code = last_code;
+     /* Paranoid check for integer overflow */
+     if (OFLOW_MAX - *lengthptr < code - last_code)
+       {
+       *errorcodeptr = ERR20;
+       goto FAILED;
+       }
      *lengthptr += code - last_code;
      DPRINTF(("length=%d added %d c=%c\n", *lengthptr, code - last_code, c));
-Line 2241 
 for (;; ptr++)
+Line 2386 
 for (;; ptr++)
      *ptrptr = ptr;
      if (lengthptr != NULL)
        {
+       if (OFLOW_MAX - *lengthptr < code - last_code)
+         {
+         *errorcodeptr = ERR20;
+         goto FAILED;
+         }
        *lengthptr += code - last_code;   /* To include callout length */
        DPRINTF((">> end branch\n"));
        }
-Line 2303 
 for (;; ptr++)
+Line 2453 
 for (;; ptr++)
        goto FAILED;
        }
-     /* If the first character is '^', set the negation flag and skip it. */
+     /* If the first character is '^', set the negation flag and skip it. Also,
+     if the first few characters (either before or after ^) are \Q\E or \E we
-     if ((c = *(++ptr)) == '^')
+     skip them too. This makes for compatibility with Perl. */
+     negate_class = FALSE;
+     for (;;)
        {
-       negate_class = TRUE;
        c = *(++ptr);
-       }
+       if (c == '\\')
-     else
+         {
-       {
+         if (ptr[1] == 'E') ptr++;
-       negate_class = FALSE;
+           else if (strncmp((const char *)ptr+1, "Q\\E", 3) == 0) ptr += 3;
-       }
+             else break;
+         }
+       else if (!negate_class && c == '^')
+         negate_class = TRUE;
+       else break;
+       }
      /* Keep a count of chars with values < 256 so that we can optimize the case
      of just a single character (as long as it's < 256). However, For higher
-Line 2453 
 for (;; ptr++)
+Line 2610 
 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.
        Elsewhere it marks a word boundary. Other escapes have preset maps ready
-       to or into the one we are building. We assume they have more than one
+       to 'or' into the one we are building. We assume they have more than one
        character in them, so set class_charcount bigger than one. */
        if (c == '\\')
-Line 2521 
 for (;; ptr++)
+Line 2678 
 for (;; ptr++)
            else if (c == -ESC_d || c == -ESC_D || c == -ESC_w ||
                     c == -ESC_W || c == -ESC_s || c == -ESC_S) continue;
+           /* We need to deal with \H, \h, \V, and \v in both phases because
+           they use extra memory. */
+           if (-c == ESC_h)
+             {
+             SETBIT(classbits, 0x09); /* VT */
+             SETBIT(classbits, 0x20); /* SPACE */
+             SETBIT(classbits, 0xa0); /* NSBP */
+ #ifdef SUPPORT_UTF8
+             if (utf8)
+               {
+               class_utf8 = TRUE;
+               *class_utf8data++ = XCL_SINGLE;
+               class_utf8data += _pcre_ord2utf8(0x1680, class_utf8data);
+               *class_utf8data++ = XCL_SINGLE;
+               class_utf8data += _pcre_ord2utf8(0x180e, class_utf8data);
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x2000, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x200A, class_utf8data);
+               *class_utf8data++ = XCL_SINGLE;
+               class_utf8data += _pcre_ord2utf8(0x202f, class_utf8data);
+               *class_utf8data++ = XCL_SINGLE;
+               class_utf8data += _pcre_ord2utf8(0x205f, class_utf8data);
+               *class_utf8data++ = XCL_SINGLE;
+               class_utf8data += _pcre_ord2utf8(0x3000, class_utf8data);
+               }
+ #endif
+             continue;
+             }
+           if (-c == ESC_H)
+             {
+             for (c = 0; c < 32; c++)
+               {
+               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;
+               }
+ #ifdef SUPPORT_UTF8
+             if (utf8)
+               {
+               class_utf8 = TRUE;
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x0100, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x167f, class_utf8data);
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x1681, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x180d, class_utf8data);
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x180f, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x1fff, class_utf8data);
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x200B, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x202e, class_utf8data);
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x2030, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x205e, class_utf8data);
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x2060, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x2fff, class_utf8data);
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x3001, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x7fffffff, class_utf8data);
+               }
+ #endif
+             continue;
+             }
+           if (-c == ESC_v)
+             {
+             SETBIT(classbits, 0x0a); /* LF */
+             SETBIT(classbits, 0x0b); /* VT */
+             SETBIT(classbits, 0x0c); /* FF */
+             SETBIT(classbits, 0x0d); /* CR */
+             SETBIT(classbits, 0x85); /* NEL */
+ #ifdef SUPPORT_UTF8
+             if (utf8)
+               {
+               class_utf8 = TRUE;
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x2028, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x2029, class_utf8data);
+               }
+ #endif
+             continue;
+             }
+           if (-c == ESC_V)
+             {
+             for (c = 0; c < 32; c++)
+               {
+               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;
+               }
+ #ifdef SUPPORT_UTF8
+             if (utf8)
+               {
+               class_utf8 = TRUE;
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x0100, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x2027, class_utf8data);
+               *class_utf8data++ = XCL_RANGE;
+               class_utf8data += _pcre_ord2utf8(0x2029, class_utf8data);
+               class_utf8data += _pcre_ord2utf8(0x7fffffff, class_utf8data);
+               }
+ #endif
+             continue;
+             }
            /* We need to deal with \P and \p in both phases. */
  #ifdef SUPPORT_UCP
-Line 2661 
 for (;; ptr++)
+Line 2945 
 for (;; ptr++)
              unsigned int origd = d;
              while (get_othercase_range(&cc, origd, &occ, &ocd))
                {
-               if (occ >= c && ocd <= d) continue;  /* Skip embedded ranges */
+               if (occ >= (unsigned int)c &&
+                   ocd <= (unsigned int)d)
+                 continue;                          /* Skip embedded ranges */
-               if (occ < c  && ocd >= c - 1)        /* Extend the basic range */
+               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 > d && occ <= d + 1)         /* always shorter than    */
+               if (ocd > (unsigned int)d &&
+                   occ <= (unsigned int)d + 1)      /* always shorter than    */
                  {                                  /* the basic range.       */
                  d = ocd;
                  continue;
-Line 2787 
 for (;; ptr++)
+Line 3075 
 for (;; ptr++)
        *errorcodeptr = ERR6;
        goto FAILED;
        }
      /* If class_charcount is 1, we saw precisely one character whose value is
      less than 256. In non-UTF-8 mode we can always optimize. In UTF-8 mode, we
      can optimize the negative case only if there were no characters >= 128
-Line 3264 
 for (;; ptr++)
+Line 3552 
 for (;; ptr++)
          goto FAILED;
          }
-       /* This is a paranoid check to stop integer overflow later on */
-       if (len > MAX_DUPLENGTH)
-         {
-         *errorcodeptr = ERR50;
-         goto FAILED;
-         }
        /* If the maximum repeat count is unlimited, find the end of the bracket
        by scanning through from the start, and compute the offset back to it
        from the current code pointer. There may be an OP_OPT setting following
-Line 3360 
 for (;; ptr++)
+Line 3640 
 for (;; ptr++)
          if (repeat_min > 1)
            {
            /* In the pre-compile phase, we don't actually do the replication. We
-           just adjust the length as if we had. */
+           just adjust the length as if we had. Do some paranoid checks for
+           potential integer overflow. */
            if (lengthptr != NULL)
-             *lengthptr += (repeat_min - 1)*length_prevgroup;
+             {
+             int delta = (repeat_min - 1)*length_prevgroup;
+             if ((double)(repeat_min - 1)*(double)length_prevgroup >
+                                                             (double)INT_MAX ||
+                 OFLOW_MAX - *lengthptr < delta)
+               {
+               *errorcodeptr = ERR20;
+               goto FAILED;
+               }
+             *lengthptr += delta;
+             }
            /* This is compiling for real */
-Line 3401 
 for (;; ptr++)
+Line 3692 
 for (;; ptr++)
          /* In the pre-compile phase, we don't actually do the replication. We
          just adjust the length as if we had. For each repetition we must add 1
          to the length for BRAZERO and for all but the last repetition we must
-         add 2 + 2*LINKSIZE to allow for the nesting that occurs. */
+         add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
+         paranoid checks to avoid integer overflow. */
          if (lengthptr != NULL && repeat_max > 0)
-           *lengthptr += repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
+           {
-- 2*LINK_SIZE;  /* Last one doesn't nest */
+           int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
+- 2*LINK_SIZE;   /* Last one doesn't nest */
+           if ((double)repeat_max *
+                 (double)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
+                   > (double)INT_MAX ||
+               OFLOW_MAX - *lengthptr < delta)
+             {
+             *errorcodeptr = ERR20;
+             goto FAILED;
+             }
+           *lengthptr += delta;
+           }
          /* This is compiling for real */
-Line 3566 
 for (;; ptr++)
+Line 3869 
 for (;; ptr++)
      skipbytes = 0;
      bravalue = OP_CBRA;
      save_hwm = cd->hwm;
+     reset_bracount = FALSE;
      if (*(++ptr) == '?')
        {
-Line 3588 
 for (;; ptr++)
+Line 3892 
 for (;; ptr++)
          /* ------------------------------------------------------------ */
+         case '|':                 /* Reset capture count for each branch */
+         reset_bracount = TRUE;
+         /* Fall through */
+         /* ------------------------------------------------------------ */
          case ':':                 /* Non-capturing bracket */
          bravalue = OP_BRA;
          ptr++;
-Line 3623 
 for (;; ptr++)
+Line 3932 
 for (;; ptr++)
          code[1+LINK_SIZE] = OP_CREF;
          skipbytes = 3;
          refsign = -1;
          /* Check for a test for recursion in a named group. */
-Line 3647 
 for (;; ptr++)
+Line 3956 
 for (;; ptr++)
            terminator = '\'';
            ptr++;
            }
          else
            {
            terminator = 0;
            if (ptr[1] == '-' || ptr[1] == '+') refsign = *(++ptr);
            }
          /* We now expect to read a name; any thing else is an error */
-Line 3689 
 for (;; ptr++)
+Line 3998 
 for (;; ptr++)
          /* In the real compile we do the work of looking for the actual
          reference. If the string started with "+" or "-" we require the rest to
          be digits, in which case recno will be set. */
          if (refsign > 0)
            {
            if (recno <= 0)
              {
              *errorcodeptr = ERR58;
              goto FAILED;
              }
            if (refsign == '-')
              {
              recno = cd->bracount - recno + 1;
              if (recno <= 0)
                {
                *errorcodeptr = ERR15;
                goto FAILED;
                }
              }
            else recno += cd->bracount;
            PUT2(code, 2+LINK_SIZE, recno);
            break;
            }
          /* Otherwise (did not start with "+" or "-"), start by looking for the
          name. */
          slot = cd->name_table;
          for (i = 0; i < cd->names_found; i++)
            {
-Line 4038 
 for (;; ptr++)
+Line 4347 
 for (;; ptr++)
            const uschar *called;
            if ((refsign = *ptr) == '+') ptr++;
            else if (refsign == '-')
              {
              if ((digitab[ptr[1]] & ctype_digit) == 0)
                goto OTHER_CHAR_AFTER_QUERY;
              ptr++;
              }
            recno = 0;
            while((digitab[*ptr] & ctype_digit) != 0)
              recno = recno * 10 + *ptr++ - '0';
-Line 4054 
 for (;; ptr++)
+Line 4363 
 for (;; ptr++)
              *errorcodeptr = ERR29;
              goto FAILED;
              }
            if (refsign == '-')
              {
              if (recno == 0)
                {
                *errorcodeptr = ERR58;
                goto FAILED;
                }
              recno = cd->bracount - recno + 1;
              if (recno <= 0)
                {
                *errorcodeptr = ERR15;
                goto FAILED;
                }
              }
            else if (refsign == '+')
              {
-Line 4075 
 for (;; ptr++)
+Line 4384 
 for (;; ptr++)
                {
                *errorcodeptr = ERR58;
                goto FAILED;
                }
              recno += cd->bracount;
              }
            /* Come here from code above that handles a named recursion */
-Line 4151 
 for (;; ptr++)
+Line 4460 
 for (;; ptr++)
          /* ------------------------------------------------------------ */
          default:              /* Other characters: check option setting */
          OTHER_CHAR_AFTER_QUERY:
          set = unset = 0;
          optset = &set;
-Line 4286 
 for (;; ptr++)
+Line 4595 
 for (;; ptr++)
           errorcodeptr,                 /* Where to put an error message */
           (bravalue == OP_ASSERTBACK ||
            bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
+          reset_bracount,               /* True if (?| group */
           skipbytes,                    /* Skip over bracket number */
           &subfirstbyte,                /* For possible first char */
           &subreqbyte,                  /* For possible last char */
-Line 4302 
 for (;; ptr++)
+Line 4612 
 for (;; ptr++)
      is on the bracket. */
      /* If this is a conditional bracket, check that there are no more than
-     two branches in the group, or just one if it's a DEFINE group. */
+     two branches in the group, or just one if it's a DEFINE group. We do this
+     in the real compile phase, not in the pre-pass, where the whole group may
+     not be available. */
-     if (bravalue == OP_COND)
+     if (bravalue == OP_COND && lengthptr == NULL)
        {
        uschar *tc = code;
        int condcount = 0;
-Line 4358 
 for (;; ptr++)
+Line 4670 
 for (;; ptr++)
      if (lengthptr != NULL)
        {
+       if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE)
+         {
+         *errorcodeptr = ERR20;
+         goto FAILED;
+         }
        *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;
        code++;
        PUTINC(code, 0, 1 + LINK_SIZE);
-Line 4464 
 for (;; ptr++)
+Line 4781 
 for (;; ptr++)
        zerofirstbyte = firstbyte;
        zeroreqbyte = reqbyte;
-       /* \k<name> or \k'name' is a back reference by name (Perl syntax) */
+       /* \k<name> or \k'name' is a back reference by name (Perl syntax).
+       We also support \k{name} (.NET syntax) */
-       if (-c == ESC_k && (ptr[1] == '<' || ptr[1] == '\''))
+       if (-c == ESC_k && (ptr[1] == '<' || ptr[1] == '\'' || ptr[1] == '{'))
          {
          is_recurse = FALSE;
-         terminator = (*(++ptr) == '<')? '>' : '\'';
+         terminator = (*(++ptr) == '<')? '>' : (*ptr == '\'')? '\'' : '}';
          goto NAMED_REF_OR_RECURSE;
          }
-Line 4635 
 This function is used during the pre-com
+Line 4953 
 This function is used during the pre-com
  out the amount of memory needed, as well as during the real compile phase. The
  value of lengthptr distinguishes the two phases.
- Argument:
+ Arguments:
    options        option bits, including any changes for this subpattern
    oldims         previous settings of ims option bits
    codeptr        -> the address of the current code pointer
    ptrptr         -> the address of the current pattern pointer
    errorcodeptr   -> pointer to error code variable
    lookbehind     TRUE if this is a lookbehind assertion
+   reset_bracount TRUE to reset the count for each branch
    skipbytes      skip this many bytes at start (for brackets and OP_COND)
    firstbyteptr   place to put the first required character, or a negative number
    reqbyteptr     place to put the last required character, or a negative number
-Line 4655 
 Returns:         TRUE on success
+Line 4974 
 Returns:         TRUE on success
  static BOOL
  compile_regex(int options, int oldims, uschar **codeptr, const uschar **ptrptr,
-   int *errorcodeptr, BOOL lookbehind, int skipbytes, int *firstbyteptr,
+   int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,
-   int *reqbyteptr, branch_chain *bcptr, compile_data *cd, int *lengthptr)
+   int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr, compile_data *cd,
+   int *lengthptr)
  {
  const uschar *ptr = *ptrptr;
  uschar *code = *codeptr;
-Line 4666 
 uschar *reverse_count = NULL;
+Line 4986 
 uschar *reverse_count = NULL;
  int firstbyte, reqbyte;
  int branchfirstbyte, branchreqbyte;
  int length;
+ int orig_bracount;
+ int max_bracount;
  branch_chain bc;
  bc.outer = bcptr;
-Line 4694 
 code += 1 + LINK_SIZE + skipbytes;
+Line 5016 
 code += 1 + LINK_SIZE + skipbytes;
  /* Loop for each alternative branch */
+ orig_bracount = max_bracount = cd->bracount;
  for (;;)
    {
+   /* For a (?| group, reset the capturing bracket count so that each branch
+   uses the same numbers. */
+   if (reset_bracount) cd->bracount = orig_bracount;
    /* Handle a change of ims options at the start of the branch */
    if ((options & PCRE_IMS) != oldims)
-Line 4725 
 for (;;)
+Line 5053 
 for (;;)
      return FALSE;
      }
+   /* Keep the highest bracket count in case (?| was used and some branch
+   has fewer than the rest. */
+   if (cd->bracount > max_bracount) max_bracount = cd->bracount;
    /* In the real compile phase, there is some post-processing to be done. */
    if (lengthptr == NULL)
-Line 4788 
 for (;;)
+Line 5121 
 for (;;)
        }
      }
-   /* Reached end of expression, either ')' or end of pattern. Go back through
+   /* Reached end of expression, either ')' or end of pattern. In the real
-   the alternative branches and reverse the chain of offsets, with the field in
+   compile phase, go back through the alternative branches and reverse the chain
-   the BRA item now becoming an offset to the first alternative. If there are
+   of offsets, with the field in the BRA item now becoming an offset to the
-   no alternatives, it points to the end of the group. The length in the
+   first alternative. If there are no alternatives, it points to the end of the
-   terminating ket is always the length of the whole bracketed item. If any of
+   group. The length in the terminating ket is always the length of the whole
-   the ims options were changed inside the group, compile a resetting op-code
+   bracketed item. If any of the ims options were changed inside the group,
-   following, except at the very end of the pattern. Return leaving the pointer
+   compile a resetting op-code following, except at the very end of the pattern.
-   at the terminating char. */
+   Return leaving the pointer at the terminating char. */
    if (*ptr != '|')
      {
-     int branch_length = code - last_branch;
+     if (lengthptr == NULL)
-     do
        {
-       int prev_length = GET(last_branch, 1);
+       int branch_length = code - last_branch;
-       PUT(last_branch, 1, branch_length);
+       do
-       branch_length = prev_length;
+         {
-       last_branch -= branch_length;
+         int prev_length = GET(last_branch, 1);
+         PUT(last_branch, 1, branch_length);
+         branch_length = prev_length;
+         last_branch -= branch_length;
+         }
+       while (branch_length > 0);
        }
-     while (branch_length > 0);
      /* Fill in the ket */
-Line 4824 
 for (;;)
+Line 5160 
 for (;;)
        length += 2;
        }
+     /* Retain the highest bracket number, in case resetting was used. */
+     cd->bracount = max_bracount;
      /* Set values to pass back */
      *codeptr = code;
      *ptrptr = ptr;
      *firstbyteptr = firstbyte;
      *reqbyteptr = reqbyte;
-     if (lengthptr != NULL) *lengthptr += length;
+     if (lengthptr != NULL)
+       {
+       if (OFLOW_MAX - *lengthptr < length)
+         {
+         *errorcodeptr = ERR20;
+         return FALSE;
+         }
+       *lengthptr += length;
+       }
      return TRUE;
      }
-   /* Another branch follows; insert an "or" node. Its length field points back
+   /* Another branch follows. In the pre-compile phase, we can move the code
+   pointer back to where it was for the start of the first branch. (That is,
+   pretend that each branch is the only one.)
+   In the real compile phase, insert an ALT node. Its length field points back
    to the previous branch while the bracket remains open. At the end the chain
    is reversed. It's done like this so that the start of the bracket has a
    zero offset until it is closed, making it possible to detect recursion. */
-   *code = OP_ALT;
+   if (lengthptr != NULL)
-   PUT(code, 1, code - last_branch);
+     {
-   bc.current = last_branch = code;
+     code = *codeptr + 1 + LINK_SIZE + skipbytes;
-   code += 1 + LINK_SIZE;
+     length += 1 + LINK_SIZE;
+     }
+   else
+     {
+     *code = OP_ALT;
+     PUT(code, 1, code - last_branch);
+     bc.current = last_branch = code;
+     code += 1 + LINK_SIZE;
+     }
    ptr++;
-   length += 1 + LINK_SIZE;
    }
  /* Control never reaches here */
  }
-Line 5286 
 outside can help speed up starting point
+Line 5646 
 outside can help speed up starting point
  code = cworkspace;
  *code = OP_BRA;
  (void)compile_regex(cd->external_options, cd->external_options & PCRE_IMS,
-   &code, &ptr, &errorcode, FALSE, 0, &firstbyte, &reqbyte, NULL, cd, &length);
+   &code, &ptr, &errorcode, FALSE, FALSE, 0, &firstbyte, &reqbyte, NULL, cd,
+   &length);
  if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;
  DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,
-Line 5354 
 ptr = (const uschar *)pattern;
+Line 5715 
 ptr = (const uschar *)pattern;
  code = (uschar *)codestart;
  *code = OP_BRA;
  (void)compile_regex(re->options, re->options & PCRE_IMS, &code, &ptr,
-   &errorcode, FALSE, 0, &firstbyte, &reqbyte, NULL, cd, NULL);
+   &errorcode, FALSE, FALSE, 0, &firstbyte, &reqbyte, NULL, cd, NULL);
  re->top_bracket = cd->bracount;
  re->top_backref = cd->top_backref;

 Legend:



Removed from v.168
 


changed lines


 
Added in v.206
 Legend:



Removed from v.168
 


changed lines


 
Added in v.206
-Removed from v.168
+Added in v.206

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12