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

Diff of /code/trunk/pcre.c

Parent Directory | Revision Log | View Patch Patch

-revision 9 by nigel,
Sat Feb 24 21:38:13 2007 UTC
+revision 17 by nigel,
Sat Feb 24 21:38:29 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 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 65 
 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 76 
 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 91 
 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 256 
 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 270 
 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 306 
 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 670 
 for (;; ptr++)
+Line 684 
 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 1015 
 for (;; ptr++)
+Line 1035 
 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 1287 
 for (;; ptr++)
+Line 1308 
 for (;; ptr++)
      the next state. */
      previous[1] = length;
-     ptr--;
+     if (length < 255) ptr--;
      break;
      }
    }                   /* end of big loop */
-Line 2041 
 while (code < code_end)
+Line 2062 
 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 2090 
 while (code < code_end)
+Line 2111 
 while (code < code_end)
      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 2714 
 for (;;)
+Line 2736 
 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 2746 
 for (;;)
+Line 2772 
 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 2763 
 for (;;)
+Line 2782 
 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 2787 
 for (;;)
+Line 2824 
 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 2807 
 for (;;)
+Line 2862 
 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 3299 
 hide it in a separate function. This is
+Line 3372 
 hide it in a separate function. This is
  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:    The block containing the match data
+ Arguments:
- Returns:      The return from setjump()
+    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 int
+ static BOOL
- my_setjmp(match_data *match_block)
+ match_with_setjmp(const uschar *eptr, const uschar *ecode, int offset_top,
+   match_data *match_block)
  {
- return setjmp(match_block->fail_env);
+ return setjmp(match_block->fail_env) == 0 &&
+       match(eptr, ecode, offset_top, match_block);
  }
-Line 3338 
 int
+Line 3418 
 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;
-Line 3347 
 const uschar *start_match = (const uscha
+Line 3426 
 const uschar *start_match = (const uscha
  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 3375 
 match_block.errorcode = PCRE_ERROR_NOMAT
+Line 3455 
 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;
+   using_temporary_offsets = TRUE;
    DPRINTF(("Got memory to hold back references\n"));
    }
  else match_block.offset_vector = offsets;
-Line 3498 
 do
+Line 3579 
 do
    it unless PCRE_EXTRA is set, since only in that case is the "cut" operation
    enabled. */
-   if (((re->options & PCRE_EXTRA) != 0 && my_setjmp(&match_block) != 0) ||
+   if ((re->options & PCRE_EXTRA) != 0)
-       !match(start_match, re->code, 2, &match_block))
+     {
-     continue;
+     if (!match_with_setjmp(start_match, re->code, 2, &match_block))
+       continue;
+     }
+   else if (!match(start_match, re->code, 2, &match_block)) continue;
    /* Copy the offset information from temporary store if necessary */
-   if (ocount != offsetcount)
+   if (using_temporary_offsets)
      {
      if (offsetcount >= 4)
        {
        memcpy(offsets + 2, match_block.offset_vector + 2,
          (offsetcount - 2) * sizeof(int));
-       DPRINTF(("Copied offsets; freeing temporary memory\n"));
+       DPRINTF(("Copied offsets from temporary memory\n"));
        }
      if (match_block.end_offset_top > offsetcount)
        match_block.offset_overflow = TRUE;
-Line 3534 
 while (!anchored &&
+Line 3618 
 while (!anchored &&
         match_block.errorcode == PCRE_ERROR_NOMATCH &&
         start_match++ < end_subject);
+ if (using_temporary_offsets)
+   {
+   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.9
 


changed lines


 
Added in v.17
 Legend:



Removed from v.9
 


changed lines


 
Added in v.17
-Removed from v.9
+Added in v.17

	ViewVC Help
Powered by ViewVC 1.1.5