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

Diff of /code/trunk/pcre.c

Parent Directory | Revision Log | View Patch Patch

-revision 7 by nigel,
Sat Feb 24 21:38:09 2007 UTC
+revision 19 by nigel,
Sat Feb 24 21:38:33 2007 UTC
 Line 9 
 the file Tech.Notes for some information
  Written by: Philip Hazel <ph10@cam.ac.uk>
-            Copyright (c) 1997 University of Cambridge
+            Copyright (c) 1998 University of Cambridge
  -----------------------------------------------------------------------------
  Permission is granted to anyone to use this software for any purpose on any
 Line 33 
 restrictions:
  /* #define DEBUG */
+ /* Use a macro for debugging printing, 'cause that eliminates the the use
+ of #ifdef inline, and there are *still* stupid compilers about that don't like
+ indented pre-processor statements. I suppose it's only been 10 years... */
+ #ifdef DEBUG
+ #define DPRINTF(p) printf p
+ #else
+ #define DPRINTF(p) /*nothing*/
+ #endif
  /* Include the internals header, which itself includes Standard C headers plus
  the external pcre header. */
-Line 40 
 the external pcre header. */
+Line 49 
 the external pcre header. */
  #include "internal.h"
+ /* Allow compilation as C++ source code, should anybody want to do that. */
+ #ifdef __cplusplus
+ #define class pcre_class
+ #endif
  /* Min and max values for the common repeats; for the maxima, 0 => infinity */
- static char rep_min[] = { 0, 0, 1, 1, 0, 0 };
+ static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
- static char rep_max[] = { 0, 0, 0, 0, 1, 1 };
+ static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };
- /* Text forms of OP_ values and things, for debugging */
+ /* Text forms of OP_ values and things, for debugging (not all used) */
  #ifdef DEBUG
  static const char *OP_names[] = {
-Line 56 
 static const char *OP_names[] = {
+Line 72 
 static const char *OP_names[] = {
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
    "*", "*?", "+", "+?", "?", "??", "{", "{",
-   "class", "Ref",
+   "class", "negclass", "Ref",
    "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not", "Once",
    "Brazero", "Braminzero", "Bra"
  };
-Line 67 
 are simple data values; negative values
+Line 83 
 are simple data values; negative values
  on. Zero means further processing is needed (for things like \x), or the escape
  is invalid. */
- static short int escapes[] = {
+ static const short int escapes[] = {
 ,      0,      0,      0,      0,      0,      0,      0,   /* 0 - 7 */
 ,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */
    '@', -ESC_A, -ESC_B,      0, -ESC_D,      0,      0,      0,   /* @ - G */
-Line 82 
 static short int escapes[] = {
+Line 98 
 static short int escapes[] = {
  /* Definition to allow mutual recursion */
- static BOOL compile_regex(int, int *, uschar **, const uschar **, const char **);
+ static BOOL
+   compile_regex(int, int *, uschar **, const uschar **, const char **);
  /* Structure for passing "static" information around between the functions
  doing the matching, so that they are thread-safe. */
-Line 187 
 Arguments:
+Line 204 
 Arguments:
  Returns:     nothing
  */
- static pchars(uschar *p, int length, BOOL is_subject, match_data *md)
+ static void
+ pchars(const uschar *p, int length, BOOL is_subject, match_data *md)
  {
  int c;
  if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
-Line 246 
 do {
+Line 264 
 do {
        case OP_KETRMIN:
        return TRUE;
+       /* Skip over entire bracket groups with zero lower bound */
+       case OP_BRAZERO:
+       case OP_BRAMINZERO:
+       cc++;
+       /* Fall through */
        /* Skip over assertive subpatterns */
        case OP_ASSERT:
-Line 260 
 do {
+Line 285 
 do {
        case OP_EOD:
        case OP_CIRC:
        case OP_DOLL:
-       case OP_BRAZERO:
-       case OP_BRAMINZERO:
        case OP_NOT_WORD_BOUNDARY:
        case OP_WORD_BOUNDARY:
        cc++;
-Line 296 
 do {
+Line 319 
 do {
        /* Check a class or a back reference for a zero minimum */
        case OP_CLASS:
+       case OP_NEGCLASS:
        case OP_REF:
        cc += (*cc == OP_REF)? 2 : 33;
-Line 599 
 compile_branch(int options, int *bracket
+Line 623 
 compile_branch(int options, int *bracket
  int repeat_type, op_type;
  int repeat_min, repeat_max;
  int bravalue, length;
+ int greedy_default, greedy_non_default;
  register int c;
  register uschar *code = *codeptr;
  const uschar *ptr = *ptrptr;
-Line 606 
 const uschar *oldptr;
+Line 631 
 const uschar *oldptr;
  uschar *previous = NULL;
  uschar class[32];
+ /* Set up the default and non-default settings for greediness */
+ greedy_default = ((options & PCRE_UNGREEDY) != 0);
+ greedy_non_default = greedy_default ^ 1;
  /* Switch on next character until the end of the branch */
  for (;; ptr++)
-Line 660 
 for (;; ptr++)
+Line 690 
 for (;; ptr++)
      case '[':
      previous = code;
-     *code++ = OP_CLASS;
-     /* If the first character is '^', set the negation flag */
+     /* If the first character is '^', set the negation flag, and use a
+     different opcode. This only matters if caseless matching is specified at
+     runtime. */
      if ((c = *(++ptr)) == '^')
        {
        negate_class = TRUE;
+       *code++ = OP_NEGCLASS;
        c = *(++ptr);
        }
-     else negate_class = FALSE;
+     else
+       {
+       negate_class = FALSE;
+       *code++ = OP_CLASS;
+       }
      /* Keep a count of chars so that we can optimize the case of just a single
      character. */
-Line 877 
 for (;; ptr++)
+Line 913 
 for (;; ptr++)
        goto FAILED;
        }
-     /* If the next character is '?' this is a minimizing repeat. Advance to the
+     /* If the next character is '?' this is a minimizing repeat, by default,
+     but if PCRE_UNGREEDY is set, it works the other way round. Advance to the
      next character. */
-     if (ptr[1] == '?') { repeat_type = 1; ptr++; } else repeat_type = 0;
+     if (ptr[1] == '?')
+       { repeat_type = greedy_non_default; ptr++; }
+     else repeat_type = greedy_default;
      /* If the maximum is zero then the minimum must also be zero; Perl allows
      this case, so we do too - by simply omitting the item altogether. */
-Line 977 
 for (;; ptr++)
+Line 1016 
 for (;; ptr++)
            if (code == previous) code += 2; else previous[1]++;
            }
-         /* Insert an UPTO if the max is greater than the min. */
+         /* If the maximum is unlimited, insert an OP_STAR. */
+         if (repeat_max < 0)
+           {
+           *code++ = c;
+           *code++ = OP_STAR + repeat_type;
+           }
+         /* Else insert an UPTO if the max is greater than the min. */
-         if (repeat_max != repeat_min)
+         else if (repeat_max != repeat_min)
            {
            *code++ = c;
            repeat_max -= repeat_min;
-Line 997 
 for (;; ptr++)
+Line 1044 
 for (;; ptr++)
      /* If previous was a character class or a back reference, we put the repeat
      stuff after it. */
-     else if (*previous == OP_CLASS || *previous == OP_REF)
+     else if (*previous == OP_CLASS || *previous == OP_NEGCLASS ||
+              *previous == OP_REF)
        {
        if (repeat_min == 0 && repeat_max == -1)
          *code++ = OP_CRSTAR + repeat_type;
-Line 1023 
 for (;; ptr++)
+Line 1071 
 for (;; ptr++)
      else if ((int)*previous >= OP_BRA)
        {
        int i;
-       int length = code - previous;
+       int len = code - previous;
        if (repeat_max == -1 && could_be_empty(previous))
          {
-Line 1040 
 for (;; ptr++)
+Line 1088 
 for (;; ptr++)
          {
          for (i = 1; i < repeat_min; i++)
            {
-           memcpy(code, previous, length);
+           memcpy(code, previous, len);
-           code += length;
+           code += len;
            }
          }
-Line 1053 
 for (;; ptr++)
+Line 1101 
 for (;; ptr++)
          {
          if (repeat_min == 0)
            {
-           memmove(previous+1, previous, length);
+           memmove(previous+1, previous, len);
            code++;
            *previous++ = OP_BRAZERO + repeat_type;
            }
          for (i = 1; i < repeat_min; i++)
            {
-           memcpy(code, previous, length);
+           memcpy(code, previous, len);
-           code += length;
+           code += len;
            }
          for (i = (repeat_min > 0)? repeat_min : 1; i < repeat_max; i++)
            {
            *code++ = OP_BRAZERO + repeat_type;
-           memcpy(code, previous, length);
+           memcpy(code, previous, len);
-           code += length;
+           code += len;
            }
          }
-Line 1110 
 for (;; ptr++)
+Line 1158 
 for (;; ptr++)
          case 'm':
          case 's':
          case 'x':
+         case 'U':
+         case 'X':
          ptr++;
          while (*ptr != ')') ptr++;
          previous = NULL;
-Line 1269 
 for (;; ptr++)
+Line 1319 
 for (;; ptr++)
      the next state. */
      previous[1] = length;
-     ptr--;
+     if (length < 255) ptr--;
      break;
      }
    }                   /* end of big loop */
-Line 1529 
 if ((options & ~PUBLIC_OPTIONS) != 0)
+Line 1579 
 if ((options & ~PUBLIC_OPTIONS) != 0)
    return NULL;
    }
- #ifdef DEBUG
+ DPRINTF(("------------------------------------------------------------------\n"));
- printf("------------------------------------------------------------------\n");
+ DPRINTF(("%s\n", pattern));
- printf("%s\n", pattern);
- #endif
  /* The first thing to do is to make a pass over the pattern to compute the
  amount of store required to hold the compiled code. This does not have to be
-Line 1647 
 while ((c = *(++ptr)) != 0)
+Line 1695 
 while ((c = *(++ptr)) != 0)
        {
        if (*ptr == '\\')
          {
-         int c = check_escape(&ptr, errorptr, bracount, options, TRUE);
+         int ch = check_escape(&ptr, errorptr, bracount, options, TRUE);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
-         if (-c == ESC_b) class_charcount++; else class_charcount = 10;
+         if (-ch == ESC_b) class_charcount++; else class_charcount = 10;
          }
        else class_charcount++;
        ptr++;
-Line 1664 
 while ((c = *(++ptr)) != 0)
+Line 1712 
 while ((c = *(++ptr)) != 0)
        /* A repeat needs either 1 or 5 bytes. */
-       if (ptr[1] == '{' && is_counted_repeat(ptr+2))
+       if (*ptr != 0 && ptr[1] == '{' && is_counted_repeat(ptr+2))
          {
          ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
-Line 1715 
 while ((c = *(++ptr)) != 0)
+Line 1763 
 while ((c = *(++ptr)) != 0)
          ptr += 2;
          break;
          }
-       /* Else fall thourh */
+       /* Else fall through */
        /* Else loop setting valid options until ) is met. Anything else is an
        error. */
-Line 1745 
 while ((c = *(++ptr)) != 0)
+Line 1793 
 while ((c = *(++ptr)) != 0)
            length -= spaces;          /* Already counted spaces */
            continue;
            }
+         else if (c == 'X')
+           {
+           options |= PCRE_EXTRA;
+           continue;
+           }
+         else if (c == 'U')
+           {
+           options |= PCRE_UNGREEDY;
+           continue;
+           }
          else if (c == ')') break;
          *errorptr = ERR12;
-Line 1772 
 while ((c = *(++ptr)) != 0)
+Line 1830 
 while ((c = *(++ptr)) != 0)
      continue;
      /* Handle ket. Look for subsequent max/min; for certain sets of values we
-     have to replicate this bracket up to that many times. */
+     have to replicate this bracket up to that many times. If brastackptr is
+this is an unmatched bracket which will generate an error, but take care
+     not to try to access brastack[-1]. */
      case ')':
      length += 3;
        {
-       int min = 1;
+       int minval = 1;
-       int max = 1;
+       int maxval = 1;
-       int duplength = length - brastack[--brastackptr];
+       int duplength = (brastackptr > 0)? length - brastack[--brastackptr] : 0;
        /* Leave ptr at the final char; for read_repeat_counts this happens
        automatically; for the others we need an increment. */
        if ((c = ptr[1]) == '{' && is_counted_repeat(ptr+2))
          {
-         ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
+         ptr = read_repeat_counts(ptr+2, &minval, &maxval, errorptr);
          if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
          }
-       else if (c == '*') { min = 0; max = -1; ptr++; }
+       else if (c == '*') { minval = 0; maxval = -1; ptr++; }
-       else if (c == '+') { max = -1; ptr++; }
+       else if (c == '+') { maxval = -1; ptr++; }
-       else if (c == '?') { min = 0; ptr++; }
+       else if (c == '?') { minval = 0; ptr++; }
-       /* If there is a minimum > 1 we have to replicate up to min-1 times; if
+       /* If there is a minimum > 1 we have to replicate up to minval-1 times;
-       there is a limited maximum we have to replicate up to max-1 times and
+       if there is a limited maximum we have to replicate up to maxval-1 times
-       allow for a BRAZERO item before each optional copy, as we also have to
+       and allow for a BRAZERO item before each optional copy, as we also have
-       do before the first copy if the minimum is zero. */
+       to do before the first copy if the minimum is zero. */
-       if (min == 0) length++;
+       if (minval == 0) length++;
-         else if (min > 1) length += (min - 1) * duplength;
+         else if (minval > 1) length += (minval - 1) * duplength;
-       if (max > min) length += (max - min) * (duplength + 1);
+       if (maxval > minval) length += (maxval - minval) * (duplength + 1);
        }
      continue;
      /* Non-special character. For a run of such characters the length required
-Line 1863 
 if (length > 65539)
+Line 1922 
 if (length > 65539)
    }
  /* Compute the size of data block needed and get it, either from malloc or
- externally provided function. Put in the magic number and the options. */
+ externally provided function. We specify "code[0]" in the offsetof() expression
+ rather than just "code", because it has been reported that one broken compiler
+ fails on "code" because it is also an independent variable. It should make no
+ difference to the value of the offsetof(). */
- size = length + offsetof(real_pcre, code);
+ size = length + offsetof(real_pcre, code[0]);
  re = (real_pcre *)(pcre_malloc)(size);
  if (re == NULL)
-Line 1874 
 if (re == NULL)
+Line 1936 
 if (re == NULL)
    return NULL;
    }
+ /* Put in the magic number and the options. */
  re->magic_number = MAGIC_NUMBER;
  re->options = options;
-Line 1924 
 if ((options & PCRE_ANCHORED) == 0)
+Line 1988 
 if ((options & PCRE_ANCHORED) == 0)
      re->options |= PCRE_ANCHORED;
    else
      {
-     int c = find_firstchar(re->code);
+     int ch = find_firstchar(re->code);
-     if (c >= 0)
+     if (ch >= 0)
        {
-       re->first_char = c;
+       re->first_char = ch;
        re->options |= PCRE_FIRSTSET;
        }
      else if (is_startline(re->code))
-Line 1944 
 printf("Length = %d top_bracket = %d top
+Line 2008 
 printf("Length = %d top_bracket = %d top
  if (re->options != 0)
    {
-   printf("%s%s%s%s%s%s%s\n",
+   printf("%s%s%s%s%s%s%s%s\n",
      ((re->options & PCRE_ANCHORED) != 0)? "anchored " : "",
      ((re->options & PCRE_CASELESS) != 0)? "caseless " : "",
      ((re->options & PCRE_EXTENDED) != 0)? "extended " : "",
      ((re->options & PCRE_MULTILINE) != 0)? "multiline " : "",
      ((re->options & PCRE_DOTALL) != 0)? "dotall " : "",
      ((re->options & PCRE_DOLLAR_ENDONLY) != 0)? "endonly " : "",
-     ((re->options & PCRE_EXTRA) != 0)? "extra " : "");
+     ((re->options & PCRE_EXTRA) != 0)? "extra " : "",
+     ((re->options & PCRE_UNGREEDY) != 0)? "ungreedy " : "");
    }
  if ((re->options & PCRE_FIRSTSET) != 0)
-Line 2019 
 while (code < code_end)
+Line 2084 
 while (code < code_end)
      case OP_MINUPTO:
      if (isprint(c = code[3])) printf("    %c{", c);
        else printf("    \\x%02x{", c);
-     if (*code != OP_EXACT) printf(",");
+     if (*code != OP_EXACT) printf("0,");
      printf("%d}", (code[1] << 8) + code[2]);
      if (*code == OP_MINUPTO) printf("?");
      code += 3;
-Line 2064 
 while (code < code_end)
+Line 2129 
 while (code < code_end)
      case OP_REF:
      printf("    \\%d", *(++code));
-     break;
+     code ++;
+     goto CLASS_REF_REPEAT;
      case OP_CLASS:
+     case OP_NEGCLASS:
        {
        int i, min, max;
-       code++;
+       if (*code++ == OP_CLASS) printf("    [");
-       printf("    [");
+         else printf("   ^[");
        for (i = 0; i < 256; i++)
          {
-Line 2094 
 while (code < code_end)
+Line 2161 
 while (code < code_end)
        printf("]");
        code += 32;
+       CLASS_REF_REPEAT:
        switch(*code)
          {
          case OP_CRSTAR:
-Line 2278 
 for (;;)
+Line 2347 
 for (;;)
      int number = (*ecode - OP_BRA) << 1;
      int save_offset1 = 0, save_offset2 = 0;
-     #ifdef DEBUG
+     DPRINTF(("start bracket %d\n", number/2));
-     printf("start bracket %d\n", number/2);
-     #endif
      if (number > 0 && number < md->offset_end)
        {
-Line 2288 
 for (;;)
+Line 2355 
 for (;;)
        save_offset2 = md->offset_vector[number+1];
        md->offset_vector[number] = eptr - md->start_subject;
-       #ifdef DEBUG
+       DPRINTF(("saving %d %d\n", save_offset1, save_offset2));
-       printf("saving %d %d\n", save_offset1, save_offset2);
-       #endif
        }
      /* Recurse for all the alternatives. */
-Line 2302 
 for (;;)
+Line 2367 
 for (;;)
        }
      while (*ecode == OP_ALT);
-     #ifdef DEBUG
+     DPRINTF(("bracket %d failed\n", number/2));
-     printf("bracket %d failed\n", number/2);
-     #endif
      if (number > 0 && number < md->offset_end)
        {
-Line 2443 
 for (;;)
+Line 2506 
 for (;;)
        number = (*prev - OP_BRA) << 1;
-       #ifdef DEBUG
+       DPRINTF(("end bracket %d\n", number/2));
-       printf("end bracket %d\n", number/2);
-       #endif
        if (number > 0)
          {
-Line 2697 
 for (;;)
+Line 2758 
 for (;;)
      item to see if there is repeat information following. Then obey similar
      code to character type repeats - written out again for speed. If caseless
      matching was set at runtime but not at compile time, we have to check both
-     versions of a character. */
+     versions of a character, and we have to behave differently for positive and
+     negative classes. This is the only time where OP_CLASS and OP_NEGCLASS are
+     treated differently. */
      case OP_CLASS:
+     case OP_NEGCLASS:
        {
+       BOOL nasty_case = *ecode == OP_NEGCLASS && md->runtime_caseless;
        const uschar *data = ecode + 1;  /* Save for matching */
        ecode += 33;                     /* Advance past the item */
-Line 2729 
 for (;;)
+Line 2794 
 for (;;)
          break;
          default:               /* No repeat follows */
-         if (eptr >= md->end_subject) return FALSE;
+         min = max = 1;
-         c = *eptr++;
+         break;
-         if ((data[c/8] & (1 << (c&7))) != 0) continue;    /* With main loop */
-         if (md->runtime_caseless)
-           {
-           c = pcre_fcc[c];
-           if ((data[c/8] & (1 << (c&7))) != 0) continue;  /* With main loop */
-           }
-         return FALSE;
          }
        /* First, ensure the minimum number of matches are present. */
-Line 2746 
 for (;;)
+Line 2804 
 for (;;)
          {
          if (eptr >= md->end_subject) return FALSE;
          c = *eptr++;
-         if ((data[c/8] & (1 << (c&7))) != 0) continue;
-         if (md->runtime_caseless)
+         /* Either not runtime caseless, or it was a positive class. For
+         runtime caseless, continue if either case is in the map. */
+         if (!nasty_case)
            {
+           if ((data[c/8] & (1 << (c&7))) != 0) continue;
+           if (md->runtime_caseless)
+             {
+             c = pcre_fcc[c];
+             if ((data[c/8] & (1 << (c&7))) != 0) continue;
+             }
+           }
+         /* Runtime caseless and it was a negative class. Continue only if
+         both cases are in the map. */
+         else
+           {
+           if ((data[c/8] & (1 << (c&7))) == 0) return FALSE;
            c = pcre_fcc[c];
            if ((data[c/8] & (1 << (c&7))) != 0) continue;
            }
          return FALSE;
          }
-Line 2770 
 for (;;)
+Line 2846 
 for (;;)
            if (match(eptr, ecode, offset_top, md)) return TRUE;
            if (i >= max || eptr >= md->end_subject) return FALSE;
            c = *eptr++;
-           if ((data[c/8] & (1 << (c&7))) != 0) continue;
-           if (md->runtime_caseless)
+           /* Either not runtime caseless, or it was a positive class. For
+           runtime caseless, continue if either case is in the map. */
+           if (!nasty_case)
+             {
+             if ((data[c/8] & (1 << (c&7))) != 0) continue;
+             if (md->runtime_caseless)
+               {
+               c = pcre_fcc[c];
+               if ((data[c/8] & (1 << (c&7))) != 0) continue;
+               }
+             }
+           /* Runtime caseless and it was a negative class. Continue only if
+           both cases are in the map. */
+           else
              {
+             if ((data[c/8] & (1 << (c&7))) == 0) return FALSE;
              c = pcre_fcc[c];
              if ((data[c/8] & (1 << (c&7))) != 0) continue;
              }
            return FALSE;
            }
          /* Control never gets here */
-Line 2790 
 for (;;)
+Line 2884 
 for (;;)
            {
            if (eptr >= md->end_subject) break;
            c = *eptr;
-           if ((data[c/8] & (1 << (c&7))) != 0) continue;
-           if (md->runtime_caseless)
+           /* Either not runtime caseless, or it was a positive class. For
+           runtime caseless, continue if either case is in the map. */
+           if (!nasty_case)
              {
+             if ((data[c/8] & (1 << (c&7))) != 0) continue;
+             if (md->runtime_caseless)
+               {
+               c = pcre_fcc[c];
+               if ((data[c/8] & (1 << (c&7))) != 0) continue;
+               }
+             }
+           /* Runtime caseless and it was a negative class. Continue only if
+           both cases are in the map. */
+           else
+             {
+             if ((data[c/8] & (1 << (c&7))) == 0) break;
              c = pcre_fcc[c];
              if ((data[c/8] & (1 << (c&7))) != 0) continue;
              }
            break;
            }
-Line 2813 
 for (;;)
+Line 2925 
 for (;;)
        register int length = ecode[1];
        ecode += 2;
-       #ifdef DEBUG
+ #ifdef DEBUG    /* Sigh. Some compilers never learn. */
        if (eptr >= md->end_subject)
          printf("matching subject <null> against pattern ");
        else
-Line 2824 
 for (;;)
+Line 2936 
 for (;;)
          }
        pchars(ecode, length, FALSE, md);
        printf("\n");
-       #endif
+ #endif
        if (length > md->end_subject - eptr) return FALSE;
        if (md->caseless)
-Line 2881 
 for (;;)
+Line 2993 
 for (;;)
      maximum. Alternatively, if maximizing, find the maximum number of
      characters and work backwards. */
-     #ifdef DEBUG
+     DPRINTF(("matching %c{%d,%d} against subject %.*s\n", c, min, max,
-     printf("matching %c{%d,%d} against subject %.*s\n", c, min, max,
+       max, eptr));
-       max, eptr);
-     #endif
      if (md->caseless)
        {
-Line 2949 
 for (;;)
+Line 3059 
 for (;;)
      /* Match a negated single character */
      case OP_NOT:
-     if (eptr > md->end_subject) return FALSE;
+     if (eptr >= md->end_subject) return FALSE;
      ecode++;
      if (md->caseless)
        {
-Line 3008 
 for (;;)
+Line 3118 
 for (;;)
      maximum. Alternatively, if maximizing, find the maximum number of
      characters and work backwards. */
-     #ifdef DEBUG
+     DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", c, min, max,
-     printf("negative matching %c{%d,%d} against subject %.*s\n", c, min, max,
+       max, eptr));
-       max, eptr);
-     #endif
      if (md->caseless)
        {
-Line 3261 
 for (;;)
+Line 3369 
 for (;;)
      /* There's been some horrible disaster. */
      default:
-     #ifdef DEBUG
+     DPRINTF(("Unknown opcode %d\n", *ecode));
-     printf("Unknown opcode %d\n", *ecode);
-     #endif
      md->errorcode = PCRE_ERROR_UNKNOWN_NODE;
      return FALSE;
      }
-Line 3279 
 for (;;)
+Line 3385 
 for (;;)
  /*************************************************
+ *         Segregate setjmp()                     *
+ *************************************************/
+ /* The -Wall option of gcc gives warnings for all local variables when setjmp()
+ is used, even if the coding conforms to the rules of ANSI C. To avoid this, we
+ hide it in a separate function. This is called only when PCRE_EXTRA is set,
+ since it's needed only for the extension \X option, and with any luck, a good
+ compiler will spot the tail recursion and compile it efficiently.
+ Arguments:
+    eptr        pointer in subject
+    ecode       position in code
+    offset_top  current top pointer
+    md          pointer to "static" info for the match
+ Returns:       TRUE if matched
+ */
+ static BOOL
+ match_with_setjmp(const uschar *eptr, const uschar *ecode, int offset_top,
+   match_data *match_block)
+ {
+ return setjmp(match_block->fail_env) == 0 &&
+       match(eptr, ecode, offset_top, match_block);
+ }
+ /*************************************************
  *         Execute a Regular Expression           *
  *************************************************/
-Line 3305 
 int
+Line 3440 
 int
  pcre_exec(const pcre *external_re, const pcre_extra *external_extra,
    const char *subject, int length, int options, int *offsets, int offsetcount)
  {
- int resetcount;
+ int resetcount, ocount;
- int ocount = offsetcount;
  int first_char = -1;
  match_data match_block;
  const uschar *start_bits = NULL;
- const uschar *start_match = (uschar *)subject;
+ const uschar *start_match = (const uschar *)subject;
  const uschar *end_subject;
  const real_pcre *re = (const real_pcre *)external_re;
  const real_pcre_extra *extra = (const real_pcre_extra *)external_extra;
+ BOOL using_temporary_offsets = FALSE;
  BOOL anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
  BOOL startline = (re->options & PCRE_STARTLINE) != 0;
-Line 3342 
 match_block.errorcode = PCRE_ERROR_NOMAT
+Line 3477 
 match_block.errorcode = PCRE_ERROR_NOMAT
  /* If the expression has got more back references than the offsets supplied can
  hold, we get a temporary bit of working store to use during the matching.
- Otherwise, we can use the vector supplied, rounding down the size of it to a
+ Otherwise, we can use the vector supplied, rounding down its size to a multiple
- multiple of 2. */
+ of 2. */
- ocount &= (-2);
+ ocount = offsetcount & (-2);
- if (re->top_backref > 0 && re->top_backref + 1 >= ocount/2)
+ if (re->top_backref > 0 && re->top_backref >= ocount/2)
    {
    ocount = re->top_backref * 2 + 2;
-   match_block.offset_vector = (pcre_malloc)(ocount * sizeof(int));
+   match_block.offset_vector = (int *)(pcre_malloc)(ocount * sizeof(int));
    if (match_block.offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
-   #ifdef DEBUG
+   using_temporary_offsets = TRUE;
-   printf("Got memory to hold back references\n");
+   DPRINTF(("Got memory to hold back references\n"));
-   #endif
    }
  else match_block.offset_vector = offsets;
-Line 3406 
 if (!anchored)
+Line 3540 
 if (!anchored)
  do
    {
+   int rc;
    register int *iptr = match_block.offset_vector;
    register int *iend = iptr + resetcount;
-Line 3447 
 do
+Line 3582 
 do
        }
      }
-   #ifdef DEBUG
+ #ifdef DEBUG  /* Sigh. Some compilers never learn. */
    printf(">>>> Match against: ");
    pchars(start_match, end_subject - start_match, TRUE, &match_block);
    printf("\n");
-   #endif
+ #endif
    /* When a match occurs, substrings will be set for all internal extractions;
    we just need to set up the whole thing as substring 0 before returning. If
-Line 3461 
 do
+Line 3596 
 do
    if certain parts of the pattern were not used.
    Before starting the match, we have to set up a longjmp() target to enable
-   the "cut" operation to fail a match completely without backtracking. */
+   the "cut" operation to fail a match completely without backtracking. This
+   is done in a separate function to avoid compiler warnings. We need not do
+   it unless PCRE_EXTRA is set, since only in that case is the "cut" operation
+   enabled. */
-   if (setjmp(match_block.fail_env) == 0 &&
+   if ((re->options & PCRE_EXTRA) != 0)
-       match(start_match, re->code, 2, &match_block))
      {
-     int rc;
+     if (!match_with_setjmp(start_match, re->code, 2, &match_block))
+       continue;
-     if (ocount != offsetcount)
+     }
-       {
+   else if (!match(start_match, re->code, 2, &match_block)) continue;
-       if (offsetcount >= 4)
-         {
-         memcpy(offsets + 2, match_block.offset_vector + 2,
-           (offsetcount - 2) * sizeof(int));
-         #ifdef DEBUG
-         printf("Copied offsets; freeing temporary memory\n");
-         #endif
-         }
-       if (match_block.end_offset_top > offsetcount)
-         match_block.offset_overflow = TRUE;
-       #ifdef DEBUG
+   /* Copy the offset information from temporary store if necessary */
-       printf("Freeing temporary memory\n");
-       #endif
-       (pcre_free)(match_block.offset_vector);
+   if (using_temporary_offsets)
+     {
+     if (offsetcount >= 4)
+       {
+       memcpy(offsets + 2, match_block.offset_vector + 2,
+         (offsetcount - 2) * sizeof(int));
+       DPRINTF(("Copied offsets from temporary memory\n"));
        }
+     if (match_block.end_offset_top > offsetcount)
+       match_block.offset_overflow = TRUE;
-     rc = match_block.offset_overflow? 0 : match_block.end_offset_top/2;
+     DPRINTF(("Freeing temporary memory\n"));
+     (pcre_free)(match_block.offset_vector);
+     }
-     if (match_block.offset_end < 2) rc = 0; else
+   rc = match_block.offset_overflow? 0 : match_block.end_offset_top/2;
-       {
-       offsets[0] = start_match - match_block.start_subject;
-       offsets[1] = match_block.end_match_ptr - match_block.start_subject;
-       }
-     #ifdef DEBUG
+   if (match_block.offset_end < 2) rc = 0; else
-     printf(">>>> returning %d\n", rc);
+     {
-     #endif
+     offsets[0] = start_match - match_block.start_subject;
-     return rc;
+     offsets[1] = match_block.end_match_ptr - match_block.start_subject;
      }
+   DPRINTF((">>>> returning %d\n", rc));
+   return rc;
    }
  while (!anchored &&
         match_block.errorcode == PCRE_ERROR_NOMATCH &&
         start_match++ < end_subject);
- #ifdef DEBUG
+ if (using_temporary_offsets)
- printf(">>>> returning %d\n", match_block.errorcode);
+   {
- #endif
+   DPRINTF(("Freeing temporary memory\n"));
+   (pcre_free)(match_block.offset_vector);
+   }
+ DPRINTF((">>>> returning %d\n", match_block.errorcode));
  return match_block.errorcode;
  }

 Legend:



Removed from v.7
 


changed lines


 
Added in v.19
 Legend:



Removed from v.7
 


changed lines


 
Added in v.19
-Removed from v.7
+Added in v.19

	ViewVC Help
Powered by ViewVC 1.1.5