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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 618 by ph10,
Sat Jul 16 17:24:16 2011 UTC
+revision 661 by ph10,
Sun Aug 21 09:00:54 2011 UTC
 Line 393 
 static const char error_texts[] =
    "internal error: previously-checked referenced subpattern not found\0"
    "DEFINE group contains more than one branch\0"
    /* 55 */
-   "repeating a DEFINE group is not allowed\0"
+   "repeating a DEFINE group is not allowed\0"  /** DEAD **/
    "inconsistent NEWLINE options\0"
    "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
    "a numbered reference must not be zero\0"
 Line 409 
 static const char error_texts[] =
    "(*MARK) must have an argument\0"
    "this version of PCRE is not compiled with PCRE_UCP support\0"
    "\\c must be followed by an ASCII character\0"
+   "\\k is not followed by a braced, angle-bracketed, or quoted name\0"
    ;
  /* Table to identify digits and hex digits. This is used when compiling
-Line 545 
 static const unsigned char ebcdic_charta
+Line 546 
 static const unsigned char ebcdic_charta
  /* Definition to allow mutual recursion */
  static BOOL
-   compile_regex(int, uschar **, const uschar **, int *, BOOL, BOOL, int, int *,
+   compile_regex(int, uschar **, const uschar **, int *, BOOL, BOOL, int, int,
-     int *, branch_chain *, compile_data *, int *);
+     int *, int *, branch_chain *, compile_data *, int *);
-Line 577 
 return s;
+Line 578 
 return s;
  /*************************************************
+ *            Check for counted repeat            *
+ *************************************************/
+ /* This function is called when a '{' is encountered in a place where it might
+ start a quantifier. It looks ahead to see if it really is a quantifier or not.
+ It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
+ where the ddds are digits.
+ Arguments:
+   p         pointer to the first char after '{'
+ Returns:    TRUE or FALSE
+ */
+ static BOOL
+ is_counted_repeat(const uschar *p)
+ {
+ if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
+ while ((digitab[*p] & ctype_digit) != 0) p++;
+ if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
+ if (*p++ != CHAR_COMMA) return FALSE;
+ if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
+ if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
+ while ((digitab[*p] & ctype_digit) != 0) p++;
+ return (*p == CHAR_RIGHT_CURLY_BRACKET);
+ }
+ /*************************************************
  *            Handle escapes                      *
  *************************************************/
-Line 647 
 else
+Line 681 
 else
      *errorcodeptr = ERR37;
      break;
-     /* \g must be followed by one of a number of specific things:
+     /* In a character class, \g is just a literal "g". Outside a character
+     class, \g must be followed by one of a number of specific things:
      (1) A number, either plain or braced. If positive, it is an absolute
      backreference. If negative, it is a relative backreference. This is a Perl
-Line 664 
 else
+Line 699 
 else
      the -ESC_g code (cf \k). */
      case CHAR_g:
+     if (isclass) break;
      if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)
        {
        c = -ESC_g;
-Line 885 
 else
+Line 921 
 else
    }
  /* Perl supports \N{name} for character names, as well as plain \N for "not
- newline". PCRE does not support \N{name}. */
+ newline". PCRE does not support \N{name}. However, it does support
+ quantification such as \N{2,3}. */
- if (c == -ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET)
+ if (c == -ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET &&
+      !is_counted_repeat(ptr+2))
    *errorcodeptr = ERR37;
  /* If PCRE_UCP is set, we change the values for \d etc. */
-Line 997 
 return -1;
+Line 1035 
 return -1;
  /*************************************************
- *            Check for counted repeat            *
- *************************************************/
- /* This function is called when a '{' is encountered in a place where it might
- start a quantifier. It looks ahead to see if it really is a quantifier or not.
- It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
- where the ddds are digits.
- Arguments:
-   p         pointer to the first char after '{'
- Returns:    TRUE or FALSE
- */
- static BOOL
- is_counted_repeat(const uschar *p)
- {
- if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
- while ((digitab[*p] & ctype_digit) != 0) p++;
- if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
- if (*p++ != CHAR_COMMA) return FALSE;
- if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
- if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
- while ((digitab[*p] & ctype_digit) != 0) p++;
- return (*p == CHAR_RIGHT_CURLY_BRACKET);
- }
- /*************************************************
  *         Read repeat counts                     *
  *************************************************/
-Line 1975 
 for (code = first_significant_code(code
+Line 1980 
 for (code = first_significant_code(code
      }
    /* For a recursion/subroutine call, if its end has been reached, which
-   implies a subroutine call, we can scan it. */
+   implies a backward reference subroutine call, we can scan it. If it's a
+   forward reference subroutine call, we can't. To detect forward reference
+   we have to scan up the list that is kept in the workspace. This function is
+   called only when doing the real compile, not during the pre-compile that
+   measures the size of the compiled pattern. */
    if (c == OP_RECURSE)
      {
-     BOOL empty_branch = FALSE;
+     const uschar *scode;
-     const uschar *scode = cd->start_code + GET(code, 1);
+     BOOL empty_branch;
+     /* 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;
+     /* Not a forward reference, test for completed backward reference */
+     empty_branch = FALSE;
+     scode = cd->start_code + GET(code, 1);
      if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
+     /* Completed backwards reference */
      do
        {
        if (could_be_empty_branch(scode, endcode, utf8, cd))
-Line 1992 
 for (code = first_significant_code(code
+Line 2014 
 for (code = first_significant_code(code
        scode += GET(scode, 1);
        }
      while (*scode == OP_ALT);
      if (!empty_branch) return FALSE;  /* All branches are non-empty */
      continue;
      }
-Line 2217 
 return TRUE;
+Line 2240 
 return TRUE;
  the current branch of the current pattern to see if it could match the empty
  string. If it could, we must look outwards for branches at other levels,
  stopping when we pass beyond the bracket which is the subject of the recursion.
+ This function is called only during the real compile, not during the
+ pre-compile.
  Arguments:
    code        points to start of the recursion
-Line 2267 
 where Perl recognizes it as the POSIX cl
+Line 2292 
 where Perl recognizes it as the POSIX cl
  "l\ower". This is a lesser evil that not diagnosing bad classes when Perl does,
  I think.
+ A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not.
+ It seems that the appearance of a nested POSIX class supersedes an apparent
+ external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or
+ a digit.
+ In Perl, unescaped square brackets may also appear as part of class names. For
+ example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for
+ [:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not
+ seem right at all. PCRE does not allow closing square brackets in POSIX class
+ names.
  Arguments:
    ptr      pointer to the initial [
    endptr   where to return the end pointer
-Line 2281 
 int terminator;          /* Don't combin
+Line 2317 
 int terminator;          /* Don't combin
  terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
  for (++ptr; *ptr != 0; ptr++)
    {
-   if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET) ptr++; else
+   if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
+     ptr++;
+   else if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
+   else
      {
-     if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
      if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
        {
        *endptr = ptr;
        return TRUE;
        }
+     if (*ptr == CHAR_LEFT_SQUARE_BRACKET &&
+          (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
+           ptr[1] == CHAR_EQUALS_SIGN) &&
+         check_posix_syntax(ptr, endptr))
+       return FALSE;
      }
    }
  return FALSE;
-Line 2998 
 Arguments:
+Line 3041 
 Arguments:
    firstbyteptr   set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
    reqbyteptr     set to the last literal character required, else < 0
    bcptr          points to current branch chain
+   cond_depth     conditional nesting depth
    cd             contains pointers to tables etc.
    lengthptr      NULL during the real compile phase
                   points to length accumulator during pre-compile phase
-Line 3009 
 Returns:         TRUE on success
+Line 3053 
 Returns:         TRUE on success
  static BOOL
  compile_branch(int *optionsptr, uschar **codeptr, const uschar **ptrptr,
    int *errorcodeptr, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
-   compile_data *cd, int *lengthptr)
+   int cond_depth, compile_data *cd, int *lengthptr)
  {
  int repeat_type, op_type;
  int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
-Line 3018 
 int greedy_default, greedy_non_default;
+Line 3062 
 int greedy_default, greedy_non_default;
  int firstbyte, reqbyte;
  int zeroreqbyte, zerofirstbyte;
  int req_caseopt, reqvary, tempreqvary;
- int options = *optionsptr;
+ int options = *optionsptr;               /* May change dynamically */
  int after_manual_callout = 0;
  int length_prevgroup = 0;
  register int c;
-Line 3036 
 uschar *previous_callout = NULL;
+Line 3080 
 uschar *previous_callout = NULL;
  uschar *save_hwm = NULL;
  uschar classbits[32];
+ /* We can fish out the UTF-8 setting once and for all into a BOOL, but we
+ must not do this for other options (e.g. PCRE_EXTENDED) because they may change
+ dynamically as we process the pattern. */
  #ifdef SUPPORT_UTF8
  BOOL class_utf8;
  BOOL utf8 = (options & PCRE_UTF8) != 0;
-Line 3216 
 for (;; ptr++)
+Line 3264 
 for (;; ptr++)
      previous_callout = NULL;
      }
-   /* In extended mode, skip white space and comments */
+   /* In extended mode, skip white space and comments. */
    if ((options & PCRE_EXTENDED) != 0)
      {
-Line 4185 
 for (;; ptr++)
+Line 4233 
 for (;; ptr++)
      op_type = 0;                    /* Default single-char op codes */
      possessive_quantifier = FALSE;  /* Default not possessive quantifier */
-     /* Save start of previous item, in case we have to move it up to make space
+     /* Save start of previous item, in case we have to move it up in order to
-     for an inserted OP_ONCE for the additional '+' extension. */
+     insert something before it. */
      tempcode = previous;
-Line 4209 
 for (;; ptr++)
+Line 4257 
 for (;; ptr++)
        }
      else repeat_type = greedy_default;
+     /* If previous was a recursion call, wrap it in atomic brackets so that
+     previous becomes the atomic group. All recursions were so wrapped in the
+     past, but it no longer happens for non-repeated recursions. In fact, the
+     repeated ones could be re-implemented independently so as not to need this,
+     but for the moment we rely on the code for repeating groups. */
+     if (*previous == OP_RECURSE)
+       {
+       memmove(previous + 1 + LINK_SIZE, previous, 1 + LINK_SIZE);
+       *previous = OP_ONCE;
+       PUT(previous, 1, 2 + 2*LINK_SIZE);
+       previous[2 + 2*LINK_SIZE] = OP_KET;
+       PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);
+       code += 2 + 2 * LINK_SIZE;
+       length_prevgroup = 3 + 3*LINK_SIZE;
+       /* When actually compiling, we need to check whether this was a forward
+       reference, and if so, adjust the offset. */
+       if (lengthptr == NULL && cd->hwm >= cd->start_workspace + LINK_SIZE)
+         {
+         int offset = GET(cd->hwm, -LINK_SIZE);
+         if (offset == previous + 1 - cd->start_code)
+           PUT(cd->hwm, -LINK_SIZE, offset + 1 + LINK_SIZE);
+         }
+       }
+     /* Now handle repetition for the different types of item. */
      /* If previous was a character match, abolish the item and generate a
      repeat item instead. If a char item has a minumum of more than one, ensure
      that it is set in reqbyte - it might not be if a sequence such as x{3} is
-Line 4500 
 for (;; ptr++)
+Line 4577 
 for (;; ptr++)
        }
      /* If previous was a bracket group, we may have to replicate it in certain
-     cases. Note that at this point we can encounter only the "basic" BRA and
+     cases. Note that at this point we can encounter only the "basic" bracket
-     KET opcodes, as this is the place where they get converted into the more
+     opcodes such as BRA and CBRA, as this is the place where they get converted
-     special varieties. */
+     into the more special varieties such as BRAPOS and SBRA. A test for >=
+     OP_ASSERT and <= OP_COND includes ASSERT, ASSERT_NOT, ASSERTBACK,
+     ASSERTBACK_NOT, ONCE, BRA, CBRA, and COND. Originally, PCRE did not allow
+     repetition of assertions, but now it does, for Perl compatibility. */
-     else if (*previous == OP_BRA  || *previous == OP_CBRA ||
+     else if (*previous >= OP_ASSERT && *previous <= OP_COND)
-              *previous == OP_ONCE || *previous == OP_COND)
        {
        register int i;
        int len = (int)(code - previous);
        uschar *bralink = NULL;
        uschar *brazeroptr = NULL;
-       /* Repeating a DEFINE group is pointless */
+       /* Repeating a DEFINE group is pointless, but Perl allows the syntax, so
+       we just ignore the repeat. */
        if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)
+         goto END_REPEAT;
+       /* There is no sense in actually repeating assertions. The only potential
+       use of repetition is in cases when the assertion is optional. Therefore,
+       if the minimum is greater than zero, just ignore the repeat. If the
+       maximum is not not zero or one, set it to 1. */
+       if (*previous < OP_ONCE)    /* Assertion */
          {
-         *errorcodeptr = ERR55;
+         if (repeat_min > 0) goto END_REPEAT;
-         goto FAILED;
+         if (repeat_max < 0 || repeat_max > 1) repeat_max = 1;
          }
        /* The case of a zero minimum is special because of the need to stick
-Line 4538 
 for (;; ptr++)
+Line 4626 
 for (;; ptr++)
          **   goto END_REPEAT;
          **   }
-         However, that fails when a group is referenced as a subroutine from
+         However, that fails when a group or a subgroup within it is referenced
-         elsewhere in the pattern, so now we stick in OP_SKIPZERO in front of it
+         as a subroutine from elsewhere in the pattern, so now we stick in
-         so that it is skipped on execution. As we don't have a list of which
+         OP_SKIPZERO in front of it so that it is skipped on execution. As we
-         groups are referenced, we cannot do this selectively.
+         don't have a list of which groups are referenced, we cannot do this
+         selectively.
          If the maximum is 1 or unlimited, we just have to stick in the BRAZERO
          and do no more at this point. However, we do need to adjust any
-Line 4727 
 for (;; ptr++)
+Line 4816 
 for (;; ptr++)
          }
        /* If the maximum is unlimited, set a repeater in the final copy. For
-       ONCE brackets, that's all we need to do.
+       ONCE brackets, that's all we need to do. However, possessively repeated
+       ONCE brackets can be converted into non-capturing brackets, as the
-       (To be done next, after recursion adjusted)
+       behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to
-       However, possessively repeated
-       ONCE brackets can be converted into non-capturing brackets, as the
-       behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to
        deal with possessive ONCEs specially.
-       (....)
        Otherwise, if the quantifier was possessive, we convert the BRA code to
        the POS form, and the KET code to KETRPOS. (It turns out to be convenient
-Line 4756 
 for (;; ptr++)
+Line 4841 
 for (;; ptr++)
          uschar *ketcode = code - 1 - LINK_SIZE;
          uschar *bracode = ketcode - GET(ketcode, 1);
- /****
+         if (*bracode == OP_ONCE && possessive_quantifier) *bracode = OP_BRA;
-         if (*bracode == OP_ONCE && possessive_quantifier)
+         if (*bracode == OP_ONCE)
-           *bracode = OP_BRA;
- ****/
-         if (*bracode == OP_ONCE)
            *ketcode = OP_KETRMAX + repeat_type;
          else
            {
-Line 4812 
 for (;; ptr++)
+Line 4893 
 for (;; ptr++)
      there are special alternative opcodes for this case. For anything else, we
      wrap the entire repeated item inside OP_ONCE brackets. Logically, the '+'
      notation is just syntactic sugar, taken from Sun's Java package, but the
      special opcodes can optimize it.
      Possessively repeated subpatterns have already been handled in the code
      just above, so possessive_quantifier is always FALSE for them at this
      stage.
      Note that the repeated item starts at tempcode, not at previous, which
      might be the first part of a string whose (former) last char we repeated.
-Line 4923 
 for (;; ptr++)
+Line 5004 
 for (;; ptr++)
        while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};
        namelen = (int)(ptr - name);
+       /* It appears that Perl allows any characters whatsoever, other than
+       a closing parenthesis, to appear in arguments, so we no longer insist on
+       letters, digits, and underscores. */
        if (*ptr == CHAR_COLON)
          {
          arg = ++ptr;
-         while ((cd->ctypes[*ptr] & (ctype_letter|ctype_digit)) != 0
+         while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
-           || *ptr == '_') ptr++;
          arglen = (int)(ptr - arg);
          }
-Line 4944 
 for (;; ptr++)
+Line 5028 
 for (;; ptr++)
          if (namelen == verbs[i].len &&
              strncmp((char *)name, vn, namelen) == 0)
            {
            /* Check for open captures before ACCEPT and convert it to
            ASSERT_ACCEPT if in an assertion. */
            if (verbs[i].op == OP_ACCEPT)
-Line 4954 
 for (;; ptr++)
+Line 5038 
 for (;; ptr++)
                {
                *errorcodeptr = ERR59;
                goto FAILED;
                }
              cd->had_accept = TRUE;
              for (oc = cd->open_caps; oc != NULL; oc = oc->next)
                {
-Line 5255 
 for (;; ptr++)
+Line 5339 
 for (;; ptr++)
          /* ------------------------------------------------------------ */
          case CHAR_EQUALS_SIGN:                 /* Positive lookahead */
          bravalue = OP_ASSERT;
          cd->assert_depth += 1;
          ptr++;
          break;
-Line 5270 
 for (;; ptr++)
+Line 5354 
 for (;; ptr++)
            continue;
            }
          bravalue = OP_ASSERT_NOT;
          cd->assert_depth += 1;
          break;
-Line 5280 
 for (;; ptr++)
+Line 5364 
 for (;; ptr++)
            {
            case CHAR_EQUALS_SIGN:               /* Positive lookbehind */
            bravalue = OP_ASSERTBACK;
            cd->assert_depth += 1;
            ptr += 2;
            break;
            case CHAR_EXCLAMATION_MARK:          /* Negative lookbehind */
            bravalue = OP_ASSERTBACK_NOT;
            cd->assert_depth += 1;
            ptr += 2;
            break;
-Line 5677 
 for (;; ptr++)
+Line 5761 
 for (;; ptr++)
                /* Fudge the value of "called" so that when it is inserted as an
                offset below, what it actually inserted is the reference number
-               of the group. */
+               of the group. Then remember the forward reference. */
                called = cd->start_code + recno;
-               PUTINC(cd->hwm, 0, (int)(code + 2 + LINK_SIZE - cd->start_code));
+               PUTINC(cd->hwm, 0, (int)(code + 1 - cd->start_code));
                }
              /* If not a forward reference, and the subpattern is still open,
              this is a recursive call. We check to see if this is a left
-             recursion that could loop for ever, and diagnose that case. */
+             recursion that could loop for ever, and diagnose that case. We
+             must not, however, do this check if we are in a conditional
+             subpattern because the condition might be testing for recursion in
+             a pattern such as /(?(R)a+|(?R)b)/, which is perfectly valid.
+             Forever loops are also detected at runtime, so those that occur in
+             conditional subpatterns will be picked up then. */
-             else if (GET(called, 1) == 0 &&
+             else if (GET(called, 1) == 0 && cond_depth <= 0 &&
                       could_be_empty(called, code, bcptr, utf8, cd))
                {
                *errorcodeptr = ERR40;
-Line 5695 
 for (;; ptr++)
+Line 5784 
 for (;; ptr++)
                }
              }
-           /* Insert the recursion/subroutine item, automatically wrapped inside
+           /* Insert the recursion/subroutine item. */
-           "once" brackets. Set up a "previous group" length so that a
-           subsequent quantifier will work. */
-           *code = OP_ONCE;
-           PUT(code, 1, 2 + 2*LINK_SIZE);
-           code += 1 + LINK_SIZE;
            *code = OP_RECURSE;
            PUT(code, 1, (int)(called - cd->start_code));
            code += 1 + LINK_SIZE;
-           *code = OP_KET;
-           PUT(code, 1, 2 + 2*LINK_SIZE);
-           code += 1 + LINK_SIZE;
-           length_prevgroup = 3 + 3*LINK_SIZE;
            }
          /* Can't determine a first byte now */
-Line 5826 
 for (;; ptr++)
+Line 5903 
 for (;; ptr++)
        skipbytes = 2;
        }
-     /* Process nested bracketed regex. Assertions may not be repeated, but
+     /* Process nested bracketed regex. Assertions used not to be repeatable,
-     other kinds can be. All their opcodes are >= OP_ONCE. We copy code into a
+     but this was changed for Perl compatibility, so all kinds can now be
-     non-register variable (tempcode) in order to be able to pass its address
+     repeated. We copy code into a non-register variable (tempcode) in order to
-     because some compilers complain otherwise. */
+     be able to pass its address because some compilers complain otherwise. */
-     previous = (bravalue >= OP_ONCE)? code : NULL;
+     previous = code;                      /* For handling repetition */
      *code = bravalue;
      tempcode = code;
-     tempreqvary = cd->req_varyopt;     /* Save value before bracket */
+     tempreqvary = cd->req_varyopt;        /* Save value before bracket */
-     length_prevgroup = 0;              /* Initialize for pre-compile phase */
+     length_prevgroup = 0;                 /* Initialize for pre-compile phase */
      if (!compile_regex(
-          newoptions,                   /* The complete new option state */
+          newoptions,                      /* The complete new option state */
-          &tempcode,                    /* Where to put code (updated) */
+          &tempcode,                       /* Where to put code (updated) */
-          &ptr,                         /* Input pointer (updated) */
+          &ptr,                            /* Input pointer (updated) */
-          errorcodeptr,                 /* Where to put an error message */
+          errorcodeptr,                    /* Where to put an error message */
           (bravalue == OP_ASSERTBACK ||
            bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
-          reset_bracount,               /* True if (?| group */
+          reset_bracount,                  /* True if (?| group */
-          skipbytes,                    /* Skip over bracket number */
+          skipbytes,                       /* Skip over bracket number */
-          &subfirstbyte,                /* For possible first char */
+          cond_depth +
-          &subreqbyte,                  /* For possible last char */
+            ((bravalue == OP_COND)?1:0),   /* Depth of condition subpatterns */
-          bcptr,                        /* Current branch chain */
+          &subfirstbyte,                   /* For possible first char */
-          cd,                           /* Tables block */
+          &subreqbyte,                     /* For possible last char */
-          (lengthptr == NULL)? NULL :   /* Actual compile phase */
+          bcptr,                           /* Current branch chain */
-            &length_prevgroup           /* Pre-compile phase */
+          cd,                              /* Tables block */
+          (lengthptr == NULL)? NULL :      /* Actual compile phase */
+            &length_prevgroup              /* Pre-compile phase */
           ))
        goto FAILED;
      if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)
        cd->assert_depth -= 1;
      /* At the end of compiling, code is still pointing to the start of the
      group, while tempcode has been updated to point past the end of the group
-Line 6096 
 for (;; ptr++)
+Line 6175 
 for (;; ptr++)
          }
        /* \k<name> or \k'name' is a back reference by name (Perl syntax).
-       We also support \k{name} (.NET syntax) */
+       We also support \k{name} (.NET syntax).  */
-       if (-c == ESC_k && (ptr[1] == CHAR_LESS_THAN_SIGN ||
+       if (-c == ESC_k)
-           ptr[1] == CHAR_APOSTROPHE || ptr[1] == CHAR_LEFT_CURLY_BRACKET))
          {
+         if ((ptr[1] != CHAR_LESS_THAN_SIGN &&
+           ptr[1] != CHAR_APOSTROPHE && ptr[1] != CHAR_LEFT_CURLY_BRACKET))
+           {
+           *errorcodeptr = ERR69;
+           break;
+           }
          is_recurse = FALSE;
          terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
            CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?
-Line 6304 
 Arguments:
+Line 6388 
 Arguments:
    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)
+   cond_depth     depth of nesting for conditional subpatterns
    firstbyteptr   place to put the first required character, or a negative number
    reqbyteptr     place to put the last required character, or a negative number
    bcptr          pointer to the chain of currently open branches
-Line 6317 
 Returns:         TRUE on success
+Line 6402 
 Returns:         TRUE on success
  static BOOL
  compile_regex(int options, uschar **codeptr, const uschar **ptrptr,
    int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,
-   int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr, compile_data *cd,
+   int cond_depth, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
-   int *lengthptr)
+   compile_data *cd, int *lengthptr)
  {
  const uschar *ptr = *ptrptr;
  uschar *code = *codeptr;
-Line 6355 
 pre-compile phase to find out whether an
+Line 6440 
 pre-compile phase to find out whether an
  /* If this is a capturing subpattern, add to the chain of open capturing items
  so that we can detect them if (*ACCEPT) is encountered. This is also used to
  detect groups that contain recursive back references to themselves. Note that
  only OP_CBRA need be tested here; changing this opcode to one of its variants,
  e.g. OP_SCBRAPOS, happens later, after the group has been compiled. */
  if (*code == OP_CBRA)
-Line 6397 
 for (;;)
+Line 6482 
 for (;;)
    into the length. */
    if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstbyte,
-         &branchreqbyte, &bc, cd, (lengthptr == NULL)? NULL : &length))
+         &branchreqbyte, &bc, cond_depth, cd,
+         (lengthptr == NULL)? NULL : &length))
      {
      *ptrptr = ptr;
      return FALSE;
-Line 6830 
 do {
+Line 6916 
 do {
       case OP_EXACT:
       scode += 2;
       /* Fall through */
       case OP_CHAR:
       case OP_PLUS:
       case OP_MINPLUS:
-Line 6843 
 do {
+Line 6929 
 do {
       case OP_EXACTI:
       scode += 2;
       /* Fall through */
       case OP_CHARI:
       case OP_PLUSI:
       case OP_MINPLUSI:
-Line 7003 
 utf8 = (options & PCRE_UTF8) != 0;
+Line 7089 
 utf8 = (options & PCRE_UTF8) != 0;
  /* Can't support UTF8 unless PCRE has been compiled to include the code. The
  return of an error code from _pcre_valid_utf8() is a new feature, introduced in
  release 8.13. It is passed back from pcre_[dfa_]exec(), but at the moment is
  not used here. */
  #ifdef SUPPORT_UTF8
-Line 7033 
 if ((options & PCRE_UCP) != 0)
+Line 7119 
 if ((options & PCRE_UCP) != 0)
  /* Check validity of \R options. */
- switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
+ if ((options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) ==
+      (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
    {
-   case 0:
+   errorcode = ERR56;
-   case PCRE_BSR_ANYCRLF:
+   goto PCRE_EARLY_ERROR_RETURN;
-   case PCRE_BSR_UNICODE:
-   break;
-   default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;
    }
  /* Handle different types of newline. The three bits give seven cases. The
-Line 7124 
 outside can help speed up starting point
+Line 7208 
 outside can help speed up starting point
  ptr += skipatstart;
  code = cworkspace;
  *code = OP_BRA;
  (void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,
-   FALSE, 0, &firstbyte, &reqbyte, NULL, cd, &length);
+   FALSE, 0, 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 7198 
 of the function here. */
+Line 7282 
 of the function here. */
  ptr = (const uschar *)pattern + skipatstart;
  code = (uschar *)codestart;
  *code = OP_BRA;
- (void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0,
+ (void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,
    &firstbyte, &reqbyte, NULL, cd, NULL);
  re->top_bracket = cd->bracount;
  re->top_backref = cd->top_backref;

 Legend:



Removed from v.618
 


changed lines


 
Added in v.661
 Legend:



Removed from v.618
 


changed lines


 
Added in v.661
-Removed from v.618
+Added in v.661

	ViewVC Help
Powered by ViewVC 1.1.5