/[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 342 by ph10, Sun Apr 20 17:10:13 2008 UTC revision 380 by ph10, Tue Mar 3 12:32:47 2009 UTC
# Line 303  static const char error_texts[] = Line 303  static const char error_texts[] =
303    "number is too big\0"    "number is too big\0"
304    "subpattern name expected\0"    "subpattern name expected\0"
305    "digit expected after (?+\0"    "digit expected after (?+\0"
306    "] is an invalid data character in JavaScript compatibility mode";    "] is an invalid data character in JavaScript compatibility mode";
307    
308    
309  /* 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 455  static const char * Line 455  static const char *
455  find_error_text(int n)  find_error_text(int n)
456  {  {
457  const char *s = error_texts;  const char *s = error_texts;
458  for (; n > 0; n--) while (*s++ != 0);  for (; n > 0; n--) while (*s++ != 0) {};
459  return s;  return s;
460  }  }
461    
# Line 533  else Line 533  else
533      break;      break;
534    
535      /* \g must be followed by one of a number of specific things:      /* \g must be followed by one of a number of specific things:
536    
537      (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
538      backreference. If negative, it is a relative backreference. This is a Perl      backreference. If negative, it is a relative backreference. This is a Perl
539      5.10 feature.      5.10 feature.
540    
541      (2) Perl 5.10 also supports \g{name} as a reference to a named group. This      (2) Perl 5.10 also supports \g{name} as a reference to a named group. This
542      is part of Perl's movement towards a unified syntax for back references. As      is part of Perl's movement towards a unified syntax for back references. As
543      this is synonymous with \k{name}, we fudge it up by pretending it really      this is synonymous with \k{name}, we fudge it up by pretending it really
544      was \k.      was \k.
545    
546      (3) For Oniguruma compatibility we also support \g followed by a name or a      (3) For Oniguruma compatibility we also support \g followed by a name or a
547      number either in angle brackets or in single quotes. However, these are      number either in angle brackets or in single quotes. However, these are
548      (possibly recursive) subroutine calls, _not_ backreferences. Just return      (possibly recursive) subroutine calls, _not_ backreferences. Just return
549      the -ESC_g code (cf \k). */      the -ESC_g code (cf \k). */
550    
551      case 'g':      case 'g':
552      if (ptr[1] == '<' || ptr[1] == '\'')      if (ptr[1] == '<' || ptr[1] == '\'')
553        {        {
554        c = -ESC_g;        c = -ESC_g;
555        break;        break;
556        }        }
557    
558      /* Handle the Perl-compatible cases */      /* Handle the Perl-compatible cases */
559    
560      if (ptr[1] == '{')      if (ptr[1] == '{')
561        {        {
562        const uschar *p;        const uschar *p;
# Line 588  else Line 588  else
588        *errorcodeptr = ERR61;        *errorcodeptr = ERR61;
589        break;        break;
590        }        }
591    
592      if (braced && *(++ptr) != '}')      if (braced && *(++ptr) != '}')
593        {        {
594        *errorcodeptr = ERR57;        *errorcodeptr = ERR57;
595        break;        break;
596        }        }
597    
598      if (c == 0)      if (c == 0)
599        {        {
600        *errorcodeptr = ERR58;        *errorcodeptr = ERR58;
601        break;        break;
602        }        }
603    
604      if (negated)      if (negated)
605        {        {
# Line 976  be terminated by '>' because that is che Line 976  be terminated by '>' because that is che
976    
977  Arguments:  Arguments:
978    ptr          current position in the pattern    ptr          current position in the pattern
979    cd           compile background data    cd           compile background data
980    name         name to seek, or NULL if seeking a numbered subpattern    name         name to seek, or NULL if seeking a numbered subpattern
981    lorn         name length, or subpattern number if name is NULL    lorn         name length, or subpattern number if name is NULL
982    xmode        TRUE if we are in /x mode    xmode        TRUE if we are in /x mode
# Line 1002  for (; *ptr != 0; ptr++) Line 1002  for (; *ptr != 0; ptr++)
1002      if (*(++ptr) == 0) return -1;      if (*(++ptr) == 0) return -1;
1003      if (*ptr == 'Q') for (;;)      if (*ptr == 'Q') for (;;)
1004        {        {
1005        while (*(++ptr) != 0 && *ptr != '\\');        while (*(++ptr) != 0 && *ptr != '\\') {};
1006        if (*ptr == 0) return -1;        if (*ptr == 0) return -1;
1007        if (*(++ptr) == 'E') break;        if (*(++ptr) == 'E') break;
1008        }        }
# Line 1033  for (; *ptr != 0; ptr++) Line 1033  for (; *ptr != 0; ptr++)
1033    
1034      /* If the next character is ']', it is a data character that must be      /* If the next character is ']', it is a data character that must be
1035      skipped, except in JavaScript compatibility mode. */      skipped, except in JavaScript compatibility mode. */
1036    
1037      if (ptr[1] == ']' && (cd->external_options & PCRE_JAVASCRIPT_COMPAT) == 0)      if (ptr[1] == ']' && (cd->external_options & PCRE_JAVASCRIPT_COMPAT) == 0)
1038        ptr++;        ptr++;
1039    
1040      while (*(++ptr) != ']')      while (*(++ptr) != ']')
1041        {        {
1042        if (*ptr == 0) return -1;        if (*ptr == 0) return -1;
# Line 1045  for (; *ptr != 0; ptr++) Line 1045  for (; *ptr != 0; ptr++)
1045          if (*(++ptr) == 0) return -1;          if (*(++ptr) == 0) return -1;
1046          if (*ptr == 'Q') for (;;)          if (*ptr == 'Q') for (;;)
1047            {            {
1048            while (*(++ptr) != 0 && *ptr != '\\');            while (*(++ptr) != 0 && *ptr != '\\') {};
1049            if (*ptr == 0) return -1;            if (*ptr == 0) return -1;
1050            if (*(++ptr) == 'E') break;            if (*(++ptr) == 'E') break;
1051            }            }
# Line 1059  for (; *ptr != 0; ptr++) Line 1059  for (; *ptr != 0; ptr++)
1059    
1060    if (xmode && *ptr == '#')    if (xmode && *ptr == '#')
1061      {      {
1062      while (*(++ptr) != 0 && *ptr != '\n');      while (*(++ptr) != 0 && *ptr != '\n') {};
1063      if (*ptr == 0) return -1;      if (*ptr == 0) return -1;
1064      continue;      continue;
1065      }      }
# Line 1450  for (;;) Line 1450  for (;;)
1450        if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];        if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
1451        break;        break;
1452        }        }
1453    #else
1454        (void)(utf8);  /* Keep compiler happy by referencing function argument */
1455  #endif  #endif
1456      }      }
1457    }    }
# Line 1543  for (;;) Line 1545  for (;;)
1545        if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];        if (code[-1] >= 0xc0) code += _pcre_utf8_table4[code[-1] & 0x3f];
1546        break;        break;
1547        }        }
1548    #else
1549        (void)(utf8);  /* Keep compiler happy by referencing function argument */
1550  #endif  #endif
1551      }      }
1552    }    }
# Line 1680  for (code = first_significant_code(code Line 1684  for (code = first_significant_code(code
1684      case OP_NOT_WORDCHAR:      case OP_NOT_WORDCHAR:
1685      case OP_WORDCHAR:      case OP_WORDCHAR:
1686      case OP_ANY:      case OP_ANY:
1687      case OP_ALLANY:      case OP_ALLANY:
1688      case OP_ANYBYTE:      case OP_ANYBYTE:
1689      case OP_CHAR:      case OP_CHAR:
1690      case OP_CHARNC:      case OP_CHARNC:
# Line 1911  while ((ptr = (uschar *)find_recurse(ptr Line 1915  while ((ptr = (uschar *)find_recurse(ptr
1915    
1916    /* See if this recursion is on the forward reference list. If so, adjust the    /* See if this recursion is on the forward reference list. If so, adjust the
1917    reference. */    reference. */
1918    
1919    for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)    for (hc = save_hwm; hc < cd->hwm; hc += LINK_SIZE)
1920      {      {
1921      offset = GET(hc, 0);      offset = GET(hc, 0);
# Line 2015  get_othercase_range(unsigned int *cptr, Line 2019  get_othercase_range(unsigned int *cptr,
2019  unsigned int c, othercase, next;  unsigned int c, othercase, next;
2020    
2021  for (c = *cptr; c <= d; c++)  for (c = *cptr; c <= d; c++)
2022    { if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR) break; }    { if ((othercase = UCD_OTHERCASE(c)) != c) break; }
2023    
2024  if (c > d) return FALSE;  if (c > d) return FALSE;
2025    
# Line 2024  next = othercase + 1; Line 2028  next = othercase + 1;
2028    
2029  for (++c; c <= d; c++)  for (++c; c <= d; c++)
2030    {    {
2031    if (_pcre_ucp_othercase(c) != next) break;    if (UCD_OTHERCASE(c) != next) break;
2032    next++;    next++;
2033    }    }
2034    
# Line 2134  if (next >= 0) switch(op_code) Line 2138  if (next >= 0) switch(op_code)
2138    case OP_CHAR:    case OP_CHAR:
2139  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
2140    if (utf8 && item > 127) { GETCHAR(item, utf8_char); }    if (utf8 && item > 127) { GETCHAR(item, utf8_char); }
2141    #else
2142      (void)(utf8_char);  /* Keep compiler happy by referencing function argument */
2143  #endif  #endif
2144    return item != next;    return item != next;
2145    
# Line 2152  if (next >= 0) switch(op_code) Line 2158  if (next >= 0) switch(op_code)
2158      unsigned int othercase;      unsigned int othercase;
2159      if (next < 128) othercase = cd->fcc[next]; else      if (next < 128) othercase = cd->fcc[next]; else
2160  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2161      othercase = _pcre_ucp_othercase((unsigned int)next);      othercase = UCD_OTHERCASE((unsigned int)next);
2162  #else  #else
2163      othercase = NOTACHAR;      othercase = NOTACHAR;
2164  #endif  #endif
# Line 2173  if (next >= 0) switch(op_code) Line 2179  if (next >= 0) switch(op_code)
2179      unsigned int othercase;      unsigned int othercase;
2180      if (next < 128) othercase = cd->fcc[next]; else      if (next < 128) othercase = cd->fcc[next]; else
2181  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2182      othercase = _pcre_ucp_othercase(next);      othercase = UCD_OTHERCASE(next);
2183  #else  #else
2184      othercase = NOTACHAR;      othercase = NOTACHAR;
2185  #endif  #endif
# Line 2487  for (;; ptr++) Line 2493  for (;; ptr++)
2493    /* Get next byte in the pattern */    /* Get next byte in the pattern */
2494    
2495    c = *ptr;    c = *ptr;
2496    
2497    /* If we are in the pre-compile phase, accumulate the length used for the    /* If we are in the pre-compile phase, accumulate the length used for the
2498    previous cycle of this loop. */    previous cycle of this loop. */
2499    
# Line 2682  for (;; ptr++) Line 2688  for (;; ptr++)
2688      opcode is compiled. It may optionally have a bit map for characters < 256,      opcode is compiled. It may optionally have a bit map for characters < 256,
2689      but those above are are explicitly listed afterwards. A flag byte tells      but those above are are explicitly listed afterwards. A flag byte tells
2690      whether the bitmap is present, and whether this is a negated class or not.      whether the bitmap is present, and whether this is a negated class or not.
2691    
2692      In JavaScript compatibility mode, an isolated ']' causes an error. In      In JavaScript compatibility mode, an isolated ']' causes an error. In
2693      default (Perl) mode, it is treated as a data character. */      default (Perl) mode, it is treated as a data character. */
2694    
2695      case ']':      case ']':
2696      if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)      if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
2697        {        {
2698        *errorcodeptr = ERR64;        *errorcodeptr = ERR64;
2699        goto FAILED;        goto FAILED;
2700        }        }
2701      goto NORMAL_CHAR;      goto NORMAL_CHAR;
2702    
2703      case '[':      case '[':
2704      previous = code;      previous = code;
# Line 2725  for (;; ptr++) Line 2731  for (;; ptr++)
2731          negate_class = TRUE;          negate_class = TRUE;
2732        else break;        else break;
2733        }        }
2734    
2735      /* Empty classes are allowed in JavaScript compatibility mode. Otherwise,      /* Empty classes are allowed in JavaScript compatibility mode. Otherwise,
2736      an initial ']' is taken as a data character -- the code below handles      an initial ']' is taken as a data character -- the code below handles
2737      that. In JS mode, [] must always fail, so generate OP_FAIL, whereas      that. In JS mode, [] must always fail, so generate OP_FAIL, whereas
2738      [^] must match any character, so generate OP_ALLANY. */      [^] must match any character, so generate OP_ALLANY. */
2739    
2740      if (c ==']' && (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)      if (c ==']' && (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
2741        {        {
2742        *code++ = negate_class? OP_ALLANY : OP_FAIL;        *code++ = negate_class? OP_ALLANY : OP_FAIL;
2743        if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;        if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
2744        zerofirstbyte = firstbyte;        zerofirstbyte = firstbyte;
2745        break;        break;
2746        }        }
2747    
2748      /* If a class contains a negative special such as \S, we need to flip the      /* If a class contains a negative special such as \S, we need to flip the
2749      negation flag at the end, so that support for characters > 255 works      negation flag at the end, so that support for characters > 255 works
# Line 3339  for (;; ptr++) Line 3345  for (;; ptr++)
3345          if ((options & PCRE_CASELESS) != 0)          if ((options & PCRE_CASELESS) != 0)
3346            {            {
3347            unsigned int othercase;            unsigned int othercase;
3348            if ((othercase = _pcre_ucp_othercase(c)) != NOTACHAR)            if ((othercase = UCD_OTHERCASE(c)) != c)
3349              {              {
3350              *class_utf8data++ = XCL_SINGLE;              *class_utf8data++ = XCL_SINGLE;
3351              class_utf8data += _pcre_ord2utf8(othercase, class_utf8data);              class_utf8data += _pcre_ord2utf8(othercase, class_utf8data);
# Line 3902  we set the flag only if there is a liter Line 3908  we set the flag only if there is a liter
3908          **   code = previous;          **   code = previous;
3909          **   goto END_REPEAT;          **   goto END_REPEAT;
3910          **   }          **   }
3911    
3912          However, that fails when a group is referenced as a subroutine from          However, that fails when a group is referenced as a subroutine from
3913          elsewhere in the pattern, so now we stick in OP_SKIPZERO in front of it          elsewhere in the pattern, so now we stick in OP_SKIPZERO in front of it
3914          so that it is skipped on execution. As we don't have a list of which          so that it is skipped on execution. As we don't have a list of which
3915          groups are referenced, we cannot do this selectively.          groups are referenced, we cannot do this selectively.
3916    
3917          If the maximum is 1 or unlimited, we just have to stick in the BRAZERO          If the maximum is 1 or unlimited, we just have to stick in the BRAZERO
3918          and do no more at this point. However, we do need to adjust any          and do no more at this point. However, we do need to adjust any
# Line 3925  we set the flag only if there is a liter Line 3931  we set the flag only if there is a liter
3931              {              {
3932              *previous++ = OP_SKIPZERO;              *previous++ = OP_SKIPZERO;
3933              goto END_REPEAT;              goto END_REPEAT;
3934              }              }
3935            *previous++ = OP_BRAZERO + repeat_type;            *previous++ = OP_BRAZERO + repeat_type;
3936            }            }
3937    
# Line 4119  we set the flag only if there is a liter Line 4125  we set the flag only if there is a liter
4125            }            }
4126          }          }
4127        }        }
4128    
4129      /* If previous is OP_FAIL, it was generated by an empty class [] in      /* If previous is OP_FAIL, it was generated by an empty class [] in
4130      JavaScript mode. The other ways in which OP_FAIL can be generated, that is      JavaScript mode. The other ways in which OP_FAIL can be generated, that is
4131      by (*FAIL) or (?!) set previous to NULL, which gives a "nothing to repeat"      by (*FAIL) or (?!) set previous to NULL, which gives a "nothing to repeat"
4132      error above. We can just ignore the repeat in JS case. */      error above. We can just ignore the repeat in JS case. */
4133    
4134      else if (*previous == OP_FAIL) goto END_REPEAT;      else if (*previous == OP_FAIL) goto END_REPEAT;
4135    
4136      /* Else there's some kind of shambles */      /* Else there's some kind of shambles */
4137    
# Line 4207  we set the flag only if there is a liter Line 4213  we set the flag only if there is a liter
4213      bravalue = OP_CBRA;      bravalue = OP_CBRA;
4214      save_hwm = cd->hwm;      save_hwm = cd->hwm;
4215      reset_bracount = FALSE;      reset_bracount = FALSE;
4216    
4217      /* First deal with various "verbs" that can be introduced by '*'. */      /* First deal with various "verbs" that can be introduced by '*'. */
4218    
4219      if (*(++ptr) == '*' && (cd->ctypes[ptr[1]] & ctype_letter) != 0)      if (*(++ptr) == '*' && (cd->ctypes[ptr[1]] & ctype_letter) != 0)
# Line 4216  we set the flag only if there is a liter Line 4222  we set the flag only if there is a liter
4222        const char *vn = verbnames;        const char *vn = verbnames;
4223        const uschar *name = ++ptr;        const uschar *name = ++ptr;
4224        previous = NULL;        previous = NULL;
4225        while ((cd->ctypes[*++ptr] & ctype_letter) != 0);        while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};
4226        if (*ptr == ':')        if (*ptr == ':')
4227          {          {
4228          *errorcodeptr = ERR59;   /* Not supported */          *errorcodeptr = ERR59;   /* Not supported */
# Line 4738  we set the flag only if there is a liter Line 4744  we set the flag only if there is a liter
4744            {            {
4745            const uschar *called;            const uschar *called;
4746            terminator = ')';            terminator = ')';
4747    
4748            /* Come here from the \g<...> and \g'...' code (Oniguruma            /* Come here from the \g<...> and \g'...' code (Oniguruma
4749            compatibility). However, the syntax has been checked to ensure that            compatibility). However, the syntax has been checked to ensure that
4750            the ... are a (signed) number, so that neither ERR63 nor ERR29 will            the ... are a (signed) number, so that neither ERR63 nor ERR29 will
4751            be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY            be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY
4752            ever be taken. */            ever be taken. */
4753    
4754            HANDLE_NUMERICAL_RECURSION:            HANDLE_NUMERICAL_RECURSION:
4755    
4756            if ((refsign = *ptr) == '+')            if ((refsign = *ptr) == '+')
4757              {              {
# Line 4920  we set the flag only if there is a liter Line 4926  we set the flag only if there is a liter
4926          both phases.          both phases.
4927    
4928          If we are not at the pattern start, compile code to change the ims          If we are not at the pattern start, compile code to change the ims
4929          options if this setting actually changes any of them. We also pass the          options if this setting actually changes any of them, and reset the
4930          new setting back so that it can be put at the start of any following          greedy defaults and the case value for firstbyte and reqbyte. */
         branches, and when this group ends (if we are in a group), a resetting  
         item can be compiled. */  
4931    
4932          if (*ptr == ')')          if (*ptr == ')')
4933            {            {
# Line 4931  we set the flag only if there is a liter Line 4935  we set the flag only if there is a liter
4935                 (lengthptr == NULL || *lengthptr == 2 + 2*LINK_SIZE))                 (lengthptr == NULL || *lengthptr == 2 + 2*LINK_SIZE))
4936              {              {
4937              cd->external_options = newoptions;              cd->external_options = newoptions;
             options = newoptions;  
4938              }              }
4939           else           else
4940              {              {
# Line 4940  we set the flag only if there is a liter Line 4943  we set the flag only if there is a liter
4943                *code++ = OP_OPT;                *code++ = OP_OPT;
4944                *code++ = newoptions & PCRE_IMS;                *code++ = newoptions & PCRE_IMS;
4945                }                }
   
             /* Change options at this level, and pass them back for use  
             in subsequent branches. Reset the greedy defaults and the case  
             value for firstbyte and reqbyte. */  
   
             *optionsptr = options = newoptions;  
4946              greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);              greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
4947              greedy_non_default = greedy_default ^ 1;              greedy_non_default = greedy_default ^ 1;
4948              req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;              req_caseopt = ((newoptions & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
4949              }              }
4950    
4951              /* Change options at this level, and pass them back for use
4952              in subsequent branches. When not at the start of the pattern, this
4953              information is also necessary so that a resetting item can be
4954              compiled at the end of a group (if we are in a group). */
4955    
4956              *optionsptr = options = newoptions;
4957            previous = NULL;       /* This item can't be repeated */            previous = NULL;       /* This item can't be repeated */
4958            continue;              /* It is complete */            continue;              /* It is complete */
4959            }            }
# Line 5163  we set the flag only if there is a liter Line 5166  we set the flag only if there is a liter
5166      back references and those types that consume a character may be repeated.      back references and those types that consume a character may be repeated.
5167      We can test for values between ESC_b and ESC_Z for the latter; this may      We can test for values between ESC_b and ESC_Z for the latter; this may
5168      have to change if any new ones are ever created. */      have to change if any new ones are ever created. */
5169    
5170      case '\\':      case '\\':
5171      tempptr = ptr;      tempptr = ptr;
5172      c = check_escape(&ptr, errorcodeptr, cd->bracount, options, FALSE);      c = check_escape(&ptr, errorcodeptr, cd->bracount, options, FALSE);
# Line 5190  we set the flag only if there is a liter Line 5193  we set the flag only if there is a liter
5193    
5194        zerofirstbyte = firstbyte;        zerofirstbyte = firstbyte;
5195        zeroreqbyte = reqbyte;        zeroreqbyte = reqbyte;
5196    
5197        /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n'        /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n'
5198        is a subroutine call by number (Oniguruma syntax). In fact, the value        is a subroutine call by number (Oniguruma syntax). In fact, the value
5199        -ESC_g is returned only for these cases. So we don't need to check for <        -ESC_g is returned only for these cases. So we don't need to check for <
5200        or ' if the value is -ESC_g. For the Perl syntax \g{n} the value is        or ' if the value is -ESC_g. For the Perl syntax \g{n} the value is
5201        -ESC_REF+n, and for the Perl syntax \g{name} the result is -ESC_k (as        -ESC_REF+n, and for the Perl syntax \g{name} the result is -ESC_k (as
5202        that is a synonym for a named back reference). */        that is a synonym for a named back reference). */
5203    
5204        if (-c == ESC_g)        if (-c == ESC_g)
5205          {          {
5206          const uschar *p;          const uschar *p;
5207          save_hwm = cd->hwm;   /* Normally this is set when '(' is read */          save_hwm = cd->hwm;   /* Normally this is set when '(' is read */
5208          terminator = (*(++ptr) == '<')? '>' : '\'';          terminator = (*(++ptr) == '<')? '>' : '\'';
5209    
5210          /* These two statements stop the compiler for warning about possibly          /* These two statements stop the compiler for warning about possibly
5211          unset variables caused by the jump to HANDLE_NUMERICAL_RECURSION. In          unset variables caused by the jump to HANDLE_NUMERICAL_RECURSION. In
5212          fact, because we actually check for a number below, the paths that          fact, because we actually check for a number below, the paths that
5213          would actually be in error are never taken. */          would actually be in error are never taken. */
5214    
5215          skipbytes = 0;          skipbytes = 0;
5216          reset_bracount = FALSE;          reset_bracount = FALSE;
5217    
5218          /* Test for a name */          /* Test for a name */
5219    
5220          if (ptr[1] != '+' && ptr[1] != '-')          if (ptr[1] != '+' && ptr[1] != '-')
5221            {            {
5222            BOOL isnumber = TRUE;            BOOL isnumber = TRUE;
5223            for (p = ptr + 1; *p != 0 && *p != terminator; p++)            for (p = ptr + 1; *p != 0 && *p != terminator; p++)
5224              {              {
5225              if ((cd->ctypes[*p] & ctype_digit) == 0) isnumber = FALSE;              if ((cd->ctypes[*p] & ctype_digit) == 0) isnumber = FALSE;
5226              if ((cd->ctypes[*p] & ctype_word) == 0) break;              if ((cd->ctypes[*p] & ctype_word) == 0) break;
5227              }              }
5228            if (*p != terminator)            if (*p != terminator)
5229              {              {
5230              *errorcodeptr = ERR57;              *errorcodeptr = ERR57;
5231              break;              break;
5232              }              }
5233            if (isnumber)            if (isnumber)
5234              {              {
5235              ptr++;              ptr++;
5236              goto HANDLE_NUMERICAL_RECURSION;              goto HANDLE_NUMERICAL_RECURSION;
5237              }              }
5238            is_recurse = TRUE;            is_recurse = TRUE;
5239            goto NAMED_REF_OR_RECURSE;            goto NAMED_REF_OR_RECURSE;
5240            }            }
5241    
5242          /* Test a signed number in angle brackets or quotes. */          /* Test a signed number in angle brackets or quotes. */
5243    
5244          p = ptr + 2;          p = ptr + 2;
5245          while ((digitab[*p] & ctype_digit) != 0) p++;          while ((digitab[*p] & ctype_digit) != 0) p++;
5246          if (*p != terminator)          if (*p != terminator)
# Line 5245  we set the flag only if there is a liter Line 5248  we set the flag only if there is a liter
5248            *errorcodeptr = ERR57;            *errorcodeptr = ERR57;
5249            break;            break;
5250            }            }
5251          ptr++;          ptr++;
5252          goto HANDLE_NUMERICAL_RECURSION;          goto HANDLE_NUMERICAL_RECURSION;
5253          }          }
5254    
5255        /* \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).
5256        We also support \k{name} (.NET syntax) */        We also support \k{name} (.NET syntax) */
# Line 5761  do { Line 5764  do {
5764     else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||     else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
5765               op == OP_TYPEPOSSTAR))               op == OP_TYPEPOSSTAR))
5766       {       {
5767       if (scode[1] != OP_ALLANY || (bracket_map & backref_map) != 0)       if (scode[1] != OP_ALLANY || (bracket_map & backref_map) != 0)
5768         return FALSE;         return FALSE;
5769       }       }
5770    
# Line 5807  do { Line 5810  do {
5810     const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],     const uschar *scode = first_significant_code(code + _pcre_OP_lengths[*code],
5811       NULL, 0, FALSE);       NULL, 0, FALSE);
5812     register int op = *scode;     register int op = *scode;
5813    
5814       /* If we are at the start of a conditional group, skip over the condition.
5815       before inspecting the first opcode after the condition. */
5816    
5817       if (op == OP_COND)
5818         {
5819         scode += 1 + LINK_SIZE;
5820         switch (*scode)
5821           {
5822           case OP_CREF:
5823           case OP_RREF:
5824           scode += 3;
5825           break;
5826    
5827           case OP_DEF:
5828           scode += 1;
5829           break;
5830    
5831           default:     /* Assertion */
5832           do scode += GET(scode, 1); while (*scode == OP_ALT);
5833           break;
5834           }
5835    
5836         scode = first_significant_code(scode, NULL, 0, FALSE);
5837         op = *scode;
5838         }
5839    
5840     /* Non-capturing brackets */     /* Non-capturing brackets */
5841    
# Line 5826  do { Line 5855  do {
5855    
5856     /* Other brackets */     /* Other brackets */
5857    
5858     else if (op == OP_ASSERT || op == OP_ONCE || op == OP_COND)     else if (op == OP_ASSERT || op == OP_ONCE)
5859       { if (!is_startline(scode, bracket_map, backref_map)) return FALSE; }       {
5860         if (!is_startline(scode, bracket_map, backref_map)) return FALSE;
5861         }
5862    
5863     /* .* means "start at start or after \n" if it isn't in brackets that     /* .* means "start at start or after \n" if it isn't in brackets that
5864     may be referenced. */     may be referenced. */
# Line 5944  Returns:        pointer to compiled data Line 5975  Returns:        pointer to compiled data
5975                  with errorptr and erroroffset set                  with errorptr and erroroffset set
5976  */  */
5977    
5978  PCRE_EXP_DEFN pcre *  PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
5979  pcre_compile(const char *pattern, int options, const char **errorptr,  pcre_compile(const char *pattern, int options, const char **errorptr,
5980    int *erroroffset, const unsigned char *tables)    int *erroroffset, const unsigned char *tables)
5981  {  {
# Line 5952  return pcre_compile2(pattern, options, N Line 5983  return pcre_compile2(pattern, options, N
5983  }  }
5984    
5985    
5986  PCRE_EXP_DEFN pcre *  PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
5987  pcre_compile2(const char *pattern, int options, int *errorcodeptr,  pcre_compile2(const char *pattern, int options, int *errorcodeptr,
5988    const char **errorptr, int *erroroffset, const unsigned char *tables)    const char **errorptr, int *erroroffset, const unsigned char *tables)
5989  {  {
# Line 6267  while (errorcode == 0 && cd->hwm > cwork Line 6298  while (errorcode == 0 && cd->hwm > cwork
6298    if (groupptr == NULL) errorcode = ERR53;    if (groupptr == NULL) errorcode = ERR53;
6299      else PUT(((uschar *)codestart), offset, groupptr - codestart);      else PUT(((uschar *)codestart), offset, groupptr - codestart);
6300    }    }
6301    
6302  /* Give an error if there's back reference to a non-existent capturing  /* Give an error if there's back reference to a non-existent capturing
6303  subpattern. */  subpattern. */
6304    

Legend:
Removed from v.342  
changed lines
  Added in v.380

  ViewVC Help
Powered by ViewVC 1.1.5