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

Diff of /code/trunk/pcre_compile.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 638 by ph10, Mon Jul 25 09:41:19 2011 UTC revision 745 by ph10, Mon Nov 14 11:41:03 2011 UTC
# Line 409  static const char error_texts[] = Line 409  static const char error_texts[] =
409    "(*MARK) must have an argument\0"    "(*MARK) must have an argument\0"
410    "this version of PCRE is not compiled with PCRE_UCP support\0"    "this version of PCRE is not compiled with PCRE_UCP support\0"
411    "\\c must be followed by an ASCII character\0"    "\\c must be followed by an ASCII character\0"
412    "\\k is not followed by a braced, angle-bracketed, or quoted name\0"    "\\k is not followed by a braced, angle-bracketed, or quoted name\0"
413    ;    ;
414    
415  /* Table to identify digits and hex digits. This is used when compiling  /* Table to identify digits and hex digits. This is used when compiling
# Line 546  static const unsigned char ebcdic_charta Line 546  static const unsigned char ebcdic_charta
546  /* Definition to allow mutual recursion */  /* Definition to allow mutual recursion */
547    
548  static BOOL  static BOOL
549    compile_regex(int, uschar **, const uschar **, int *, BOOL, BOOL, int, int *,    compile_regex(int, uschar **, const uschar **, int *, BOOL, BOOL, int, int,
550      int *, branch_chain *, compile_data *, int *);      int *, int *, branch_chain *, compile_data *, int *);
551    
552    
553    
# Line 578  return s; Line 578  return s;
578    
579    
580  /*************************************************  /*************************************************
581    *            Check for counted repeat            *
582    *************************************************/
583    
584    /* This function is called when a '{' is encountered in a place where it might
585    start a quantifier. It looks ahead to see if it really is a quantifier or not.
586    It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
587    where the ddds are digits.
588    
589    Arguments:
590      p         pointer to the first char after '{'
591    
592    Returns:    TRUE or FALSE
593    */
594    
595    static BOOL
596    is_counted_repeat(const uschar *p)
597    {
598    if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
599    while ((digitab[*p] & ctype_digit) != 0) p++;
600    if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
601    
602    if (*p++ != CHAR_COMMA) return FALSE;
603    if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
604    
605    if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
606    while ((digitab[*p] & ctype_digit) != 0) p++;
607    
608    return (*p == CHAR_RIGHT_CURLY_BRACKET);
609    }
610    
611    
612    
613    /*************************************************
614  *            Handle escapes                      *  *            Handle escapes                      *
615  *************************************************/  *************************************************/
616    
# Line 643  else Line 676  else
676    
677      case CHAR_l:      case CHAR_l:
678      case CHAR_L:      case CHAR_L:
679        *errorcodeptr = ERR37;
680        break;
681    
682      case CHAR_u:      case CHAR_u:
683        if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)
684          {
685          /* In JavaScript, \u must be followed by four hexadecimal numbers.
686          Otherwise it is a lowercase u letter. */
687          if ((digitab[ptr[1]] & ctype_xdigit) != 0 && (digitab[ptr[2]] & ctype_xdigit) != 0
688               && (digitab[ptr[3]] & ctype_xdigit) != 0 && (digitab[ptr[4]] & ctype_xdigit) != 0)
689            {
690            c = 0;
691            for (i = 0; i < 4; ++i)
692              {
693              register int cc = *(++ptr);
694    #ifndef EBCDIC  /* ASCII/UTF-8 coding */
695              if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
696              c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
697    #else           /* EBCDIC coding */
698              if (cc >= CHAR_a && cc <= CHAR_z) cc += 64;  /* Convert to upper case */
699              c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
700    #endif
701              }
702            }
703          }
704        else
705          *errorcodeptr = ERR37;
706        break;
707    
708      case CHAR_U:      case CHAR_U:
709      *errorcodeptr = ERR37;      /* In JavaScript, \U is an uppercase U letter. */
710        if ((options & PCRE_JAVASCRIPT_COMPAT) == 0) *errorcodeptr = ERR37;
711      break;      break;
712    
713      /* \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
714        class, \g must be followed by one of a number of specific things:
715    
716      (1) A number, either plain or braced. If positive, it is an absolute      (1) A number, either plain or braced. If positive, it is an absolute
717      backreference. If negative, it is a relative backreference. This is a Perl      backreference. If negative, it is a relative backreference. This is a Perl
# Line 665  else Line 728  else
728      the -ESC_g code (cf \k). */      the -ESC_g code (cf \k). */
729    
730      case CHAR_g:      case CHAR_g:
731        if (isclass) break;
732      if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)      if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)
733        {        {
734        c = -ESC_g;        c = -ESC_g;
# Line 793  else Line 857  else
857      treated as a data character. */      treated as a data character. */
858    
859      case CHAR_x:      case CHAR_x:
860        if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)
861          {
862          /* In JavaScript, \x must be followed by two hexadecimal numbers.
863          Otherwise it is a lowercase x letter. */
864          if ((digitab[ptr[1]] & ctype_xdigit) != 0 && (digitab[ptr[2]] & ctype_xdigit) != 0)
865            {
866            c = 0;
867            for (i = 0; i < 2; ++i)
868              {
869              register int cc = *(++ptr);
870    #ifndef EBCDIC  /* ASCII/UTF-8 coding */
871              if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
872              c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
873    #else           /* EBCDIC coding */
874              if (cc >= CHAR_a && cc <= CHAR_z) cc += 64;  /* Convert to upper case */
875              c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
876    #endif
877              }
878            }
879          break;
880          }
881    
882      if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)      if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
883        {        {
884        const uschar *pt = ptr + 2;        const uschar *pt = ptr + 2;
# Line 886  else Line 972  else
972    }    }
973    
974  /* Perl supports \N{name} for character names, as well as plain \N for "not  /* Perl supports \N{name} for character names, as well as plain \N for "not
975  newline". PCRE does not support \N{name}. */  newline". PCRE does not support \N{name}. However, it does support
976    quantification such as \N{2,3}. */
977    
978  if (c == -ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET)  if (c == -ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET &&
979         !is_counted_repeat(ptr+2))
980    *errorcodeptr = ERR37;    *errorcodeptr = ERR37;
981    
982  /* If PCRE_UCP is set, we change the values for \d etc. */  /* If PCRE_UCP is set, we change the values for \d etc. */
# Line 998  return -1; Line 1086  return -1;
1086    
1087    
1088  /*************************************************  /*************************************************
 *            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);  
 }  
   
   
   
 /*************************************************  
1089  *         Read repeat counts                     *  *         Read repeat counts                     *
1090  *************************************************/  *************************************************/
1091    
# Line 1502  for (;;) Line 1557  for (;;)
1557      case OP_CBRA:      case OP_CBRA:
1558      case OP_BRA:      case OP_BRA:
1559      case OP_ONCE:      case OP_ONCE:
1560        case OP_ONCE_NC:
1561      case OP_COND:      case OP_COND:
1562      d = find_fixedlength(cc + ((op == OP_CBRA)? 2:0), utf8, atend, cd);      d = find_fixedlength(cc + ((op == OP_CBRA)? 2:0), utf8, atend, cd);
1563      if (d < 0) return d;      if (d < 0) return d;
# Line 1757  for (;;) Line 1813  for (;;)
1813        break;        break;
1814    
1815        case OP_THEN_ARG:        case OP_THEN_ARG:
1816        code += code[1+LINK_SIZE];        code += code[1];
1817        break;        break;
1818        }        }
1819    
# Line 1876  for (;;) Line 1932  for (;;)
1932        break;        break;
1933    
1934        case OP_THEN_ARG:        case OP_THEN_ARG:
1935        code += code[1+LINK_SIZE];        code += code[1];
1936        break;        break;
1937        }        }
1938    
# Line 1978  for (code = first_significant_code(code Line 2034  for (code = first_significant_code(code
2034    /* For a recursion/subroutine call, if its end has been reached, which    /* For a recursion/subroutine call, if its end has been reached, which
2035    implies a backward reference subroutine call, we can scan it. If it's a    implies a backward reference subroutine call, we can scan it. If it's a
2036    forward reference subroutine call, we can't. To detect forward reference    forward reference subroutine call, we can't. To detect forward reference
2037    we have to scan up the list that is kept in the workspace. This function is    we have to scan up the list that is kept in the workspace. This function is
2038    called only when doing the real compile, not during the pre-compile that    called only when doing the real compile, not during the pre-compile that
2039    measures the size of the compiled pattern. */    measures the size of the compiled pattern. */
2040    
2041    if (c == OP_RECURSE)    if (c == OP_RECURSE)
2042      {      {
2043      const uschar *scode;      const uschar *scode;
2044      BOOL empty_branch;      BOOL empty_branch;
2045    
2046      /* Test for forward reference */      /* Test for forward reference */
2047    
2048      for (scode = cd->start_workspace; scode < cd->hwm; scode += LINK_SIZE)      for (scode = cd->start_workspace; scode < cd->hwm; scode += LINK_SIZE)
2049        if (GET(scode, 0) == code + 1 - cd->start_code) return TRUE;        if (GET(scode, 0) == code + 1 - cd->start_code) return TRUE;
2050    
2051      /* Not a forward reference, test for completed backward reference */      /* Not a forward reference, test for completed backward reference */
2052    
2053      empty_branch = FALSE;      empty_branch = FALSE;
2054      scode = cd->start_code + GET(code, 1);      scode = cd->start_code + GET(code, 1);
2055      if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */      if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
2056    
2057      /* Completed backwards reference */      /* Completed backwards reference */
2058    
2059      do      do
2060        {        {
2061        if (could_be_empty_branch(scode, endcode, utf8, cd))        if (could_be_empty_branch(scode, endcode, utf8, cd))
# Line 2010  for (code = first_significant_code(code Line 2066  for (code = first_significant_code(code
2066        scode += GET(scode, 1);        scode += GET(scode, 1);
2067        }        }
2068      while (*scode == OP_ALT);      while (*scode == OP_ALT);
2069    
2070      if (!empty_branch) return FALSE;  /* All branches are non-empty */      if (!empty_branch) return FALSE;  /* All branches are non-empty */
2071      continue;      continue;
2072      }      }
# Line 2041  for (code = first_significant_code(code Line 2097  for (code = first_significant_code(code
2097    
2098    if (c == OP_BRA  || c == OP_BRAPOS ||    if (c == OP_BRA  || c == OP_BRAPOS ||
2099        c == OP_CBRA || c == OP_CBRAPOS ||        c == OP_CBRA || c == OP_CBRAPOS ||
2100        c == OP_ONCE || c == OP_COND)        c == OP_ONCE || c == OP_ONCE_NC ||
2101          c == OP_COND)
2102      {      {
2103      BOOL empty_branch;      BOOL empty_branch;
2104      if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */      if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */
# Line 2213  for (code = first_significant_code(code Line 2270  for (code = first_significant_code(code
2270      break;      break;
2271    
2272      case OP_THEN_ARG:      case OP_THEN_ARG:
2273      code += code[1+LINK_SIZE];      code += code[1];
2274      break;      break;
2275    
2276      /* None of the remaining opcodes are required to match a character. */      /* None of the remaining opcodes are required to match a character. */
# Line 2236  return TRUE; Line 2293  return TRUE;
2293  the current branch of the current pattern to see if it could match the empty  the current branch of the current pattern to see if it could match the empty
2294  string. If it could, we must look outwards for branches at other levels,  string. If it could, we must look outwards for branches at other levels,
2295  stopping when we pass beyond the bracket which is the subject of the recursion.  stopping when we pass beyond the bracket which is the subject of the recursion.
2296  This function is called only during the real compile, not during the  This function is called only during the real compile, not during the
2297  pre-compile.  pre-compile.
2298    
2299  Arguments:  Arguments:
# Line 2288  where Perl recognizes it as the POSIX cl Line 2345  where Perl recognizes it as the POSIX cl
2345  "l\ower". This is a lesser evil that not diagnosing bad classes when Perl does,  "l\ower". This is a lesser evil that not diagnosing bad classes when Perl does,
2346  I think.  I think.
2347    
2348    A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not.
2349    It seems that the appearance of a nested POSIX class supersedes an apparent
2350    external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or
2351    a digit.
2352    
2353    In Perl, unescaped square brackets may also appear as part of class names. For
2354    example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for
2355    [:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not
2356    seem right at all. PCRE does not allow closing square brackets in POSIX class
2357    names.
2358    
2359  Arguments:  Arguments:
2360    ptr      pointer to the initial [    ptr      pointer to the initial [
2361    endptr   where to return the end pointer    endptr   where to return the end pointer
# Line 2302  int terminator;          /* Don't combin Line 2370  int terminator;          /* Don't combin
2370  terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */  terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
2371  for (++ptr; *ptr != 0; ptr++)  for (++ptr; *ptr != 0; ptr++)
2372    {    {
2373    if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET) ptr++; else    if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
2374        ptr++;
2375      else if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
2376      else
2377      {      {
     if (*ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;  
2378      if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)      if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
2379        {        {
2380        *endptr = ptr;        *endptr = ptr;
2381        return TRUE;        return TRUE;
2382        }        }
2383        if (*ptr == CHAR_LEFT_SQUARE_BRACKET &&
2384             (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
2385              ptr[1] == CHAR_EQUALS_SIGN) &&
2386            check_posix_syntax(ptr, endptr))
2387          return FALSE;
2388      }      }
2389    }    }
2390  return FALSE;  return FALSE;
# Line 3019  Arguments: Line 3094  Arguments:
3094    firstbyteptr   set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)    firstbyteptr   set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
3095    reqbyteptr     set to the last literal character required, else < 0    reqbyteptr     set to the last literal character required, else < 0
3096    bcptr          points to current branch chain    bcptr          points to current branch chain
3097      cond_depth     conditional nesting depth
3098    cd             contains pointers to tables etc.    cd             contains pointers to tables etc.
3099    lengthptr      NULL during the real compile phase    lengthptr      NULL during the real compile phase
3100                   points to length accumulator during pre-compile phase                   points to length accumulator during pre-compile phase
# Line 3030  Returns:         TRUE on success Line 3106  Returns:         TRUE on success
3106  static BOOL  static BOOL
3107  compile_branch(int *optionsptr, uschar **codeptr, const uschar **ptrptr,  compile_branch(int *optionsptr, uschar **codeptr, const uschar **ptrptr,
3108    int *errorcodeptr, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,    int *errorcodeptr, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
3109    compile_data *cd, int *lengthptr)    int cond_depth, compile_data *cd, int *lengthptr)
3110  {  {
3111  int repeat_type, op_type;  int repeat_type, op_type;
3112  int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */  int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
# Line 3058  uschar *save_hwm = NULL; Line 3134  uschar *save_hwm = NULL;
3134  uschar classbits[32];  uschar classbits[32];
3135    
3136  /* We can fish out the UTF-8 setting once and for all into a BOOL, but we  /* We can fish out the UTF-8 setting once and for all into a BOOL, but we
3137  must not do this for other options (e.g. PCRE_EXTENDED) because they may change  must not do this for other options (e.g. PCRE_EXTENDED) because they may change
3138  dynamically as we process the pattern. */  dynamically as we process the pattern. */
3139    
3140  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 3069  uschar *class_utf8data_base; Line 3145  uschar *class_utf8data_base;
3145  uschar utf8_char[6];  uschar utf8_char[6];
3146  #else  #else
3147  BOOL utf8 = FALSE;  BOOL utf8 = FALSE;
 uschar *utf8_char = NULL;  
3148  #endif  #endif
3149    
3150  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
# Line 3120  for (;; ptr++) Line 3195  for (;; ptr++)
3195    int subfirstbyte;    int subfirstbyte;
3196    int terminator;    int terminator;
3197    int mclength;    int mclength;
3198      int tempbracount;
3199    uschar mcbuffer[8];    uschar mcbuffer[8];
3200    
3201    /* Get next byte in the pattern */    /* Get next byte in the pattern */
# Line 4233  for (;; ptr++) Line 4309  for (;; ptr++)
4309        ptr++;        ptr++;
4310        }        }
4311      else repeat_type = greedy_default;      else repeat_type = greedy_default;
4312    
4313      /* If previous was a recursion call, wrap it in atomic brackets so that      /* If previous was a recursion call, wrap it in atomic brackets so that
4314      previous becomes the atomic group. All recursions were so wrapped in the      previous becomes the atomic group. All recursions were so wrapped in the
4315      past, but it no longer happens for non-repeated recursions. In fact, the      past, but it no longer happens for non-repeated recursions. In fact, the
4316      repeated ones could be re-implemented independently so as not to need this,      repeated ones could be re-implemented independently so as not to need this,
4317      but for the moment we rely on the code for repeating groups. */      but for the moment we rely on the code for repeating groups. */
4318    
4319      if (*previous == OP_RECURSE)      if (*previous == OP_RECURSE)
4320        {        {
4321        memmove(previous + 1 + LINK_SIZE, previous, 1 + LINK_SIZE);        memmove(previous + 1 + LINK_SIZE, previous, 1 + LINK_SIZE);
# Line 4249  for (;; ptr++) Line 4325  for (;; ptr++)
4325        PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);        PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);
4326        code += 2 + 2 * LINK_SIZE;        code += 2 + 2 * LINK_SIZE;
4327        length_prevgroup = 3 + 3*LINK_SIZE;        length_prevgroup = 3 + 3*LINK_SIZE;
4328    
4329        /* When actually compiling, we need to check whether this was a forward        /* When actually compiling, we need to check whether this was a forward
4330        reference, and if so, adjust the offset. */        reference, and if so, adjust the offset. */
4331    
4332        if (lengthptr == NULL && cd->hwm >= cd->start_workspace + LINK_SIZE)        if (lengthptr == NULL && cd->hwm >= cd->start_workspace + LINK_SIZE)
4333          {          {
4334          int offset = GET(cd->hwm, -LINK_SIZE);          int offset = GET(cd->hwm, -LINK_SIZE);
4335          if (offset == previous + 1 - cd->start_code)          if (offset == previous + 1 - cd->start_code)
4336            PUT(cd->hwm, -LINK_SIZE, offset + 1 + LINK_SIZE);            PUT(cd->hwm, -LINK_SIZE, offset + 1 + LINK_SIZE);
4337          }          }
4338        }        }
4339    
4340      /* Now handle repetition for the different types of item. */      /* Now handle repetition for the different types of item. */
4341    
4342      /* If previous was a character match, abolish the item and generate a      /* If previous was a character match, abolish the item and generate a
# Line 4558  for (;; ptr++) Line 4634  for (;; ptr++)
4634      opcodes such as BRA and CBRA, as this is the place where they get converted      opcodes such as BRA and CBRA, as this is the place where they get converted
4635      into the more special varieties such as BRAPOS and SBRA. A test for >=      into the more special varieties such as BRAPOS and SBRA. A test for >=
4636      OP_ASSERT and <= OP_COND includes ASSERT, ASSERT_NOT, ASSERTBACK,      OP_ASSERT and <= OP_COND includes ASSERT, ASSERT_NOT, ASSERTBACK,
4637      ASSERTBACK_NOT, ONCE, BRA, CBRA, and COND. Originally, PCRE did not allow      ASSERTBACK_NOT, ONCE, BRA, CBRA, and COND. Originally, PCRE did not allow
4638      repetition of assertions, but now it does, for Perl compatibility. */      repetition of assertions, but now it does, for Perl compatibility. */
4639    
4640      else if (*previous >= OP_ASSERT && *previous <= OP_COND)      else if (*previous >= OP_ASSERT && *previous <= OP_COND)
4641        {        {
4642        register int i;        register int i;
4643        int len = (int)(code - previous);        int len = (int)(code - previous);
4644        uschar *bralink = NULL;        uschar *bralink = NULL;
4645        uschar *brazeroptr = NULL;        uschar *brazeroptr = NULL;
4646    
4647        /* Repeating a DEFINE group is pointless, but Perl allows the syntax, so        /* Repeating a DEFINE group is pointless, but Perl allows the syntax, so
4648        we just ignore the repeat. */        we just ignore the repeat. */
4649    
4650        if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)        if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)
4651          goto END_REPEAT;          goto END_REPEAT;
4652    
4653        /* There is no sense in actually repeating assertions. The only potential        /* There is no sense in actually repeating assertions. The only potential
4654        use of repetition is in cases when the assertion is optional. Therefore,        use of repetition is in cases when the assertion is optional. Therefore,
4655        if the minimum is greater than zero, just ignore the repeat. If the        if the minimum is greater than zero, just ignore the repeat. If the
4656        maximum is not not zero or one, set it to 1. */        maximum is not not zero or one, set it to 1. */
4657    
4658        if (*previous < OP_ONCE)    /* Assertion */        if (*previous < OP_ONCE)    /* Assertion */
4659          {          {
4660          if (repeat_min > 0) goto END_REPEAT;          if (repeat_min > 0) goto END_REPEAT;
4661          if (repeat_max < 0 || repeat_max > 1) repeat_max = 1;          if (repeat_max < 0 || repeat_max > 1) repeat_max = 1;
4662          }          }
4663    
4664        /* The case of a zero minimum is special because of the need to stick        /* The case of a zero minimum is special because of the need to stick
4665        OP_BRAZERO in front of it, and because the group appears once in the        OP_BRAZERO in front of it, and because the group appears once in the
# Line 4817  for (;; ptr++) Line 4893  for (;; ptr++)
4893          {          {
4894          uschar *ketcode = code - 1 - LINK_SIZE;          uschar *ketcode = code - 1 - LINK_SIZE;
4895          uschar *bracode = ketcode - GET(ketcode, 1);          uschar *bracode = ketcode - GET(ketcode, 1);
4896    
4897          if (*bracode == OP_ONCE && possessive_quantifier) *bracode = OP_BRA;          if ((*bracode == OP_ONCE || *bracode == OP_ONCE_NC) &&
4898          if (*bracode == OP_ONCE)              possessive_quantifier) *bracode = OP_BRA;
4899    
4900            if (*bracode == OP_ONCE || *bracode == OP_ONCE_NC)
4901            *ketcode = OP_KETRMAX + repeat_type;            *ketcode = OP_KETRMAX + repeat_type;
4902          else          else
4903            {            {
# Line 4870  for (;; ptr++) Line 4948  for (;; ptr++)
4948      there are special alternative opcodes for this case. For anything else, we      there are special alternative opcodes for this case. For anything else, we
4949      wrap the entire repeated item inside OP_ONCE brackets. Logically, the '+'      wrap the entire repeated item inside OP_ONCE brackets. Logically, the '+'
4950      notation is just syntactic sugar, taken from Sun's Java package, but the      notation is just syntactic sugar, taken from Sun's Java package, but the
4951      special opcodes can optimize it.      special opcodes can optimize it.
4952    
4953      Possessively repeated subpatterns have already been handled in the code      Possessively repeated subpatterns have already been handled in the code
4954      just above, so possessive_quantifier is always FALSE for them at this      just above, so possessive_quantifier is always FALSE for them at this
4955      stage.      stage.
4956    
4957      Note that the repeated item starts at tempcode, not at previous, which      Note that the repeated item starts at tempcode, not at previous, which
4958      might be the first part of a string whose (former) last char we repeated.      might be the first part of a string whose (former) last char we repeated.
4959    
# Line 4981  for (;; ptr++) Line 5059  for (;; ptr++)
5059        while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};        while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};
5060        namelen = (int)(ptr - name);        namelen = (int)(ptr - name);
5061    
5062          /* It appears that Perl allows any characters whatsoever, other than
5063          a closing parenthesis, to appear in arguments, so we no longer insist on
5064          letters, digits, and underscores. */
5065    
5066        if (*ptr == CHAR_COLON)        if (*ptr == CHAR_COLON)
5067          {          {
5068          arg = ++ptr;          arg = ++ptr;
5069          while ((cd->ctypes[*ptr] & (ctype_letter|ctype_digit)) != 0          while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
           || *ptr == '_') ptr++;  
5070          arglen = (int)(ptr - arg);          arglen = (int)(ptr - arg);
5071          }          }
5072    
# Line 5002  for (;; ptr++) Line 5083  for (;; ptr++)
5083          if (namelen == verbs[i].len &&          if (namelen == verbs[i].len &&
5084              strncmp((char *)name, vn, namelen) == 0)              strncmp((char *)name, vn, namelen) == 0)
5085            {            {
5086            /* Check for open captures before ACCEPT and convert it to            /* Check for open captures before ACCEPT and convert it to
5087            ASSERT_ACCEPT if in an assertion. */            ASSERT_ACCEPT if in an assertion. */
5088    
5089            if (verbs[i].op == OP_ACCEPT)            if (verbs[i].op == OP_ACCEPT)
# Line 5012  for (;; ptr++) Line 5093  for (;; ptr++)
5093                {                {
5094                *errorcodeptr = ERR59;                *errorcodeptr = ERR59;
5095                goto FAILED;                goto FAILED;
5096                }                }
5097              cd->had_accept = TRUE;              cd->had_accept = TRUE;
5098              for (oc = cd->open_caps; oc != NULL; oc = oc->next)              for (oc = cd->open_caps; oc != NULL; oc = oc->next)
5099                {                {
# Line 5020  for (;; ptr++) Line 5101  for (;; ptr++)
5101                PUT2INC(code, 0, oc->number);                PUT2INC(code, 0, oc->number);
5102                }                }
5103              *code++ = (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;              *code++ = (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;
5104    
5105                /* Do not set firstbyte after *ACCEPT */
5106                if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
5107              }              }
5108    
5109            /* Handle other cases with/without an argument */            /* Handle other cases with/without an argument */
# Line 5032  for (;; ptr++) Line 5116  for (;; ptr++)
5116                goto FAILED;                goto FAILED;
5117                }                }
5118              *code = verbs[i].op;              *code = verbs[i].op;
5119              if (*code++ == OP_THEN)              if (*code++ == OP_THEN) cd->external_flags |= PCRE_HASTHEN;
               {  
               PUT(code, 0, code - bcptr->current_branch - 1);  
               code += LINK_SIZE;  
               }  
5120              }              }
5121    
5122            else            else
# Line 5047  for (;; ptr++) Line 5127  for (;; ptr++)
5127                goto FAILED;                goto FAILED;
5128                }                }
5129              *code = verbs[i].op_arg;              *code = verbs[i].op_arg;
5130              if (*code++ == OP_THEN_ARG)              if (*code++ == OP_THEN_ARG) cd->external_flags |= PCRE_HASTHEN;
               {  
               PUT(code, 0, code - bcptr->current_branch - 1);  
               code += LINK_SIZE;  
               }  
5131              *code++ = arglen;              *code++ = arglen;
5132              memcpy(code, arg, arglen);              memcpy(code, arg, arglen);
5133              code += arglen;              code += arglen;
# Line 5313  for (;; ptr++) Line 5389  for (;; ptr++)
5389          /* ------------------------------------------------------------ */          /* ------------------------------------------------------------ */
5390          case CHAR_EQUALS_SIGN:                 /* Positive lookahead */          case CHAR_EQUALS_SIGN:                 /* Positive lookahead */
5391          bravalue = OP_ASSERT;          bravalue = OP_ASSERT;
5392          cd->assert_depth += 1;          cd->assert_depth += 1;
5393          ptr++;          ptr++;
5394          break;          break;
5395    
# Line 5328  for (;; ptr++) Line 5404  for (;; ptr++)
5404            continue;            continue;
5405            }            }
5406          bravalue = OP_ASSERT_NOT;          bravalue = OP_ASSERT_NOT;
5407          cd->assert_depth += 1;          cd->assert_depth += 1;
5408          break;          break;
5409    
5410    
# Line 5338  for (;; ptr++) Line 5414  for (;; ptr++)
5414            {            {
5415            case CHAR_EQUALS_SIGN:               /* Positive lookbehind */            case CHAR_EQUALS_SIGN:               /* Positive lookbehind */
5416            bravalue = OP_ASSERTBACK;            bravalue = OP_ASSERTBACK;
5417            cd->assert_depth += 1;            cd->assert_depth += 1;
5418            ptr += 2;            ptr += 2;
5419            break;            break;
5420    
5421            case CHAR_EXCLAMATION_MARK:          /* Negative lookbehind */            case CHAR_EXCLAMATION_MARK:          /* Negative lookbehind */
5422            bravalue = OP_ASSERTBACK_NOT;            bravalue = OP_ASSERTBACK_NOT;
5423            cd->assert_depth += 1;            cd->assert_depth += 1;
5424            ptr += 2;            ptr += 2;
5425            break;            break;
5426    
# Line 5588  for (;; ptr++) Line 5664  for (;; ptr++)
5664    
5665            temp = cd->end_pattern;            temp = cd->end_pattern;
5666            cd->end_pattern = ptr;            cd->end_pattern = ptr;
5667            recno = find_parens(cd, name, namelen,            recno = find_parens(cd, name, namelen,
5668              (options & PCRE_EXTENDED) != 0, utf8);              (options & PCRE_EXTENDED) != 0, utf8);
5669            cd->end_pattern = temp;            cd->end_pattern = temp;
5670            if (recno < 0) recno = 0;    /* Forward ref; set dummy number */            if (recno < 0) recno = 0;    /* Forward ref; set dummy number */
# Line 5743  for (;; ptr++) Line 5819  for (;; ptr++)
5819    
5820              /* If not a forward reference, and the subpattern is still open,              /* If not a forward reference, and the subpattern is still open,
5821              this is a recursive call. We check to see if this is a left              this is a recursive call. We check to see if this is a left
5822              recursion that could loop for ever, and diagnose that case. */              recursion that could loop for ever, and diagnose that case. We
5823                must not, however, do this check if we are in a conditional
5824                subpattern because the condition might be testing for recursion in
5825                a pattern such as /(?(R)a+|(?R)b)/, which is perfectly valid.
5826                Forever loops are also detected at runtime, so those that occur in
5827                conditional subpatterns will be picked up then. */
5828    
5829              else if (GET(called, 1) == 0 &&              else if (GET(called, 1) == 0 && cond_depth <= 0 &&
5830                       could_be_empty(called, code, bcptr, utf8, cd))                       could_be_empty(called, code, bcptr, utf8, cd))
5831                {                {
5832                *errorcodeptr = ERR40;                *errorcodeptr = ERR40;
# Line 5754  for (;; ptr++) Line 5835  for (;; ptr++)
5835              }              }
5836    
5837            /* Insert the recursion/subroutine item. */            /* Insert the recursion/subroutine item. */
5838    
5839            *code = OP_RECURSE;            *code = OP_RECURSE;
5840            PUT(code, 1, (int)(called - cd->start_code));            PUT(code, 1, (int)(called - cd->start_code));
5841            code += 1 + LINK_SIZE;            code += 1 + LINK_SIZE;
# Line 5877  for (;; ptr++) Line 5958  for (;; ptr++)
5958      repeated. We copy code into a non-register variable (tempcode) in order to      repeated. We copy code into a non-register variable (tempcode) in order to
5959      be able to pass its address because some compilers complain otherwise. */      be able to pass its address because some compilers complain otherwise. */
5960    
5961      previous = code;                   /* For handling repetition */      previous = code;                      /* For handling repetition */
5962      *code = bravalue;      *code = bravalue;
5963      tempcode = code;      tempcode = code;
5964      tempreqvary = cd->req_varyopt;     /* Save value before bracket */      tempreqvary = cd->req_varyopt;        /* Save value before bracket */
5965      length_prevgroup = 0;              /* Initialize for pre-compile phase */      tempbracount = cd->bracount;          /* Save value before bracket */
5966        length_prevgroup = 0;                 /* Initialize for pre-compile phase */
5967    
5968      if (!compile_regex(      if (!compile_regex(
5969           newoptions,                   /* The complete new option state */           newoptions,                      /* The complete new option state */
5970           &tempcode,                    /* Where to put code (updated) */           &tempcode,                       /* Where to put code (updated) */
5971           &ptr,                         /* Input pointer (updated) */           &ptr,                            /* Input pointer (updated) */
5972           errorcodeptr,                 /* Where to put an error message */           errorcodeptr,                    /* Where to put an error message */
5973           (bravalue == OP_ASSERTBACK ||           (bravalue == OP_ASSERTBACK ||
5974            bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */            bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
5975           reset_bracount,               /* True if (?| group */           reset_bracount,                  /* True if (?| group */
5976           skipbytes,                    /* Skip over bracket number */           skipbytes,                       /* Skip over bracket number */
5977           &subfirstbyte,                /* For possible first char */           cond_depth +
5978           &subreqbyte,                  /* For possible last char */             ((bravalue == OP_COND)?1:0),   /* Depth of condition subpatterns */
5979           bcptr,                        /* Current branch chain */           &subfirstbyte,                   /* For possible first char */
5980           cd,                           /* Tables block */           &subreqbyte,                     /* For possible last char */
5981           (lengthptr == NULL)? NULL :   /* Actual compile phase */           bcptr,                           /* Current branch chain */
5982             &length_prevgroup           /* Pre-compile phase */           cd,                              /* Tables block */
5983             (lengthptr == NULL)? NULL :      /* Actual compile phase */
5984               &length_prevgroup              /* Pre-compile phase */
5985           ))           ))
5986        goto FAILED;        goto FAILED;
5987    
5988        /* If this was an atomic group and there are no capturing groups within it,
5989        generate OP_ONCE_NC instead of OP_ONCE. */
5990    
5991        if (bravalue == OP_ONCE && cd->bracount <= tempbracount)
5992          *code = OP_ONCE_NC;
5993    
5994      if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)      if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)
5995        cd->assert_depth -= 1;        cd->assert_depth -= 1;
5996    
5997      /* At the end of compiling, code is still pointing to the start of the      /* At the end of compiling, code is still pointing to the start of the
5998      group, while tempcode has been updated to point past the end of the group      group, while tempcode has been updated to point past the end of the group.
5999      and any option resetting that may follow it. The pattern pointer (ptr)      The pattern pointer (ptr) is on the bracket.
     is on the bracket. */  
6000    
6001      /* If this is a conditional bracket, check that there are no more than      If this is a conditional bracket, check that there are no more than
6002      two branches in the group, or just one if it's a DEFINE group. We do this      two branches in the group, or just one if it's a DEFINE group. We do this
6003      in the real compile phase, not in the pre-pass, where the whole group may      in the real compile phase, not in the pre-pass, where the whole group may
6004      not be available. */      not be available. */
# Line 6150  for (;; ptr++) Line 6239  for (;; ptr++)
6239            ptr[1] != CHAR_APOSTROPHE && ptr[1] != CHAR_LEFT_CURLY_BRACKET))            ptr[1] != CHAR_APOSTROPHE && ptr[1] != CHAR_LEFT_CURLY_BRACKET))
6240            {            {
6241            *errorcodeptr = ERR69;            *errorcodeptr = ERR69;
6242            break;            break;
6243            }            }
6244          is_recurse = FALSE;          is_recurse = FALSE;
6245          terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?          terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
6246            CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?            CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?
6247            CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;            CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;
6248          goto NAMED_REF_OR_RECURSE;          goto NAMED_REF_OR_RECURSE;
6249          }          }
6250    
6251        /* Back references are handled specially; must disable firstbyte if        /* Back references are handled specially; must disable firstbyte if
6252        not set to cope with cases like (?=(\w+))\1: which would otherwise set        not set to cope with cases like (?=(\w+))\1: which would otherwise set
# Line 6308  for (;; ptr++) Line 6397  for (;; ptr++)
6397        else firstbyte = reqbyte = REQ_NONE;        else firstbyte = reqbyte = REQ_NONE;
6398        }        }
6399    
6400      /* firstbyte was previously set; we can set reqbyte only the length is      /* firstbyte was previously set; we can set reqbyte only if the length is
6401      1 or the matching is caseful. */      1 or the matching is caseful. */
6402    
6403      else      else
# Line 6355  Arguments: Line 6444  Arguments:
6444    lookbehind     TRUE if this is a lookbehind assertion    lookbehind     TRUE if this is a lookbehind assertion
6445    reset_bracount TRUE to reset the count for each branch    reset_bracount TRUE to reset the count for each branch
6446    skipbytes      skip this many bytes at start (for brackets and OP_COND)    skipbytes      skip this many bytes at start (for brackets and OP_COND)
6447      cond_depth     depth of nesting for conditional subpatterns
6448    firstbyteptr   place to put the first required character, or a negative number    firstbyteptr   place to put the first required character, or a negative number
6449    reqbyteptr     place to put the last required character, or a negative number    reqbyteptr     place to put the last required character, or a negative number
6450    bcptr          pointer to the chain of currently open branches    bcptr          pointer to the chain of currently open branches
# Line 6368  Returns:         TRUE on success Line 6458  Returns:         TRUE on success
6458  static BOOL  static BOOL
6459  compile_regex(int options, uschar **codeptr, const uschar **ptrptr,  compile_regex(int options, uschar **codeptr, const uschar **ptrptr,
6460    int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,    int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,
6461    int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr, compile_data *cd,    int cond_depth, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
6462    int *lengthptr)    compile_data *cd, int *lengthptr)
6463  {  {
6464  const uschar *ptr = *ptrptr;  const uschar *ptr = *ptrptr;
6465  uschar *code = *codeptr;  uschar *code = *codeptr;
# Line 6406  pre-compile phase to find out whether an Line 6496  pre-compile phase to find out whether an
6496    
6497  /* If this is a capturing subpattern, add to the chain of open capturing items  /* If this is a capturing subpattern, add to the chain of open capturing items
6498  so that we can detect them if (*ACCEPT) is encountered. This is also used to  so that we can detect them if (*ACCEPT) is encountered. This is also used to
6499  detect groups that contain recursive back references to themselves. Note that  detect groups that contain recursive back references to themselves. Note that
6500  only OP_CBRA need be tested here; changing this opcode to one of its variants,  only OP_CBRA need be tested here; changing this opcode to one of its variants,
6501  e.g. OP_SCBRAPOS, happens later, after the group has been compiled. */  e.g. OP_SCBRAPOS, happens later, after the group has been compiled. */
6502    
6503  if (*code == OP_CBRA)  if (*code == OP_CBRA)
# Line 6448  for (;;) Line 6538  for (;;)
6538    into the length. */    into the length. */
6539    
6540    if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstbyte,    if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstbyte,
6541          &branchreqbyte, &bc, cd, (lengthptr == NULL)? NULL : &length))          &branchreqbyte, &bc, cond_depth, cd,
6542            (lengthptr == NULL)? NULL : &length))
6543      {      {
6544      *ptrptr = ptr;      *ptrptr = ptr;
6545      return FALSE;      return FALSE;
# Line 6698  do { Line 6789  do {
6789    
6790     /* Other brackets */     /* Other brackets */
6791    
6792     else if (op == OP_ASSERT || op == OP_ONCE || op == OP_COND)     else if (op == OP_ASSERT || op == OP_ONCE || op == OP_ONCE_NC ||
6793                op == OP_COND)
6794       {       {
6795       if (!is_anchored(scode, bracket_map, backref_map)) return FALSE;       if (!is_anchored(scode, bracket_map, backref_map)) return FALSE;
6796       }       }
# Line 6802  do { Line 6894  do {
6894    
6895     /* Other brackets */     /* Other brackets */
6896    
6897     else if (op == OP_ASSERT || op == OP_ONCE)     else if (op == OP_ASSERT || op == OP_ONCE || op == OP_ONCE_NC)
6898       {       {
6899       if (!is_startline(scode, bracket_map, backref_map)) return FALSE;       if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
6900       }       }
# Line 6872  do { Line 6964  do {
6964       case OP_SCBRAPOS:       case OP_SCBRAPOS:
6965       case OP_ASSERT:       case OP_ASSERT:
6966       case OP_ONCE:       case OP_ONCE:
6967         case OP_ONCE_NC:
6968       case OP_COND:       case OP_COND:
6969       if ((d = find_firstassertedchar(scode, op == OP_ASSERT)) < 0)       if ((d = find_firstassertedchar(scode, op == OP_ASSERT)) < 0)
6970         return -1;         return -1;
# Line 6881  do { Line 6974  do {
6974       case OP_EXACT:       case OP_EXACT:
6975       scode += 2;       scode += 2;
6976       /* Fall through */       /* Fall through */
6977    
6978       case OP_CHAR:       case OP_CHAR:
6979       case OP_PLUS:       case OP_PLUS:
6980       case OP_MINPLUS:       case OP_MINPLUS:
# Line 6894  do { Line 6987  do {
6987       case OP_EXACTI:       case OP_EXACTI:
6988       scode += 2;       scode += 2;
6989       /* Fall through */       /* Fall through */
6990    
6991       case OP_CHARI:       case OP_CHARI:
6992       case OP_PLUSI:       case OP_PLUSI:
6993       case OP_MINPLUSI:       case OP_MINPLUSI:
# Line 7054  utf8 = (options & PCRE_UTF8) != 0; Line 7147  utf8 = (options & PCRE_UTF8) != 0;
7147    
7148  /* Can't support UTF8 unless PCRE has been compiled to include the code. The  /* Can't support UTF8 unless PCRE has been compiled to include the code. The
7149  return of an error code from _pcre_valid_utf8() is a new feature, introduced in  return of an error code from _pcre_valid_utf8() is a new feature, introduced in
7150  release 8.13. It is passed back from pcre_[dfa_]exec(), but at the moment is  release 8.13. It is passed back from pcre_[dfa_]exec(), but at the moment is
7151  not used here. */  not used here. */
7152    
7153  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 7087  if ((options & PCRE_UCP) != 0) Line 7180  if ((options & PCRE_UCP) != 0)
7180  if ((options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) ==  if ((options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) ==
7181       (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))       (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
7182    {    {
7183    errorcode = ERR56;    errorcode = ERR56;
7184    goto PCRE_EARLY_ERROR_RETURN;    goto PCRE_EARLY_ERROR_RETURN;
7185    }    }
7186    
# Line 7173  outside can help speed up starting point Line 7266  outside can help speed up starting point
7266  ptr += skipatstart;  ptr += skipatstart;
7267  code = cworkspace;  code = cworkspace;
7268  *code = OP_BRA;  *code = OP_BRA;
7269  (void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,  (void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,
7270    FALSE, 0, &firstbyte, &reqbyte, NULL, cd, &length);    FALSE, 0, 0, &firstbyte, &reqbyte, NULL, cd, &length);
7271  if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;  if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;
7272    
7273  DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,  DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,
# Line 7247  of the function here. */ Line 7340  of the function here. */
7340  ptr = (const uschar *)pattern + skipatstart;  ptr = (const uschar *)pattern + skipatstart;
7341  code = (uschar *)codestart;  code = (uschar *)codestart;
7342  *code = OP_BRA;  *code = OP_BRA;
7343  (void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0,  (void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,
7344    &firstbyte, &reqbyte, NULL, cd, NULL);    &firstbyte, &reqbyte, NULL, cd, NULL);
7345  re->top_bracket = cd->bracount;  re->top_bracket = cd->bracount;
7346  re->top_backref = cd->top_backref;  re->top_backref = cd->top_backref;
7347  re->flags = cd->external_flags;  re->flags = cd->external_flags;
7348    
7349  if (cd->had_accept) reqbyte = -1;   /* Must disable after (*ACCEPT) */  if (cd->had_accept) reqbyte = REQ_NONE;   /* Must disable after (*ACCEPT) */
7350    
7351  /* If not reached end of pattern on success, there's an excess bracket. */  /* If not reached end of pattern on success, there's an excess bracket. */
7352    

Legend:
Removed from v.638  
changed lines
  Added in v.745

  ViewVC Help
Powered by ViewVC 1.1.5