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

Diff of /code/trunk/pcre.c

Parent Directory | Revision Log | View Patch Patch

-revision 25 by nigel,
Sat Feb 24 21:38:45 2007 UTC
+revision 33 by nigel,
Sat Feb 24 21:39:01 2007 UTC
 Line 9 
 the file Tech.Notes for some information
  Written by: Philip Hazel <ph10@cam.ac.uk>
-            Copyright (c) 1998 University of Cambridge
+            Copyright (c) 1997-1999 University of Cambridge
  -----------------------------------------------------------------------------
  Permission is granted to anyone to use this software for any purpose on any
 Line 25 
 restrictions:
 . Altered versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
+. If PCRE is embedded in any software that is released under the GNU
+    General Purpose Licence (GPL), then the terms of that licence shall
+    supersede any condition above with which it is incompatible.
  -----------------------------------------------------------------------------
  */
-Line 1087 
 for (;; ptr++)
+Line 1091 
 for (;; ptr++)
      else if ((int)*previous >= OP_BRA || (int)*previous == OP_ONCE ||
               (int)*previous == OP_COND)
        {
-       int i, ketoffset = 0;
+       register int i;
+       int ketoffset = 0;
        int len = code - previous;
+       uschar *bralink = NULL;
        /* If the maximum repeat count is unlimited, find the end of the bracket
        by scanning through from the start, and compute the offset back to it
-Line 1103 
 for (;; ptr++)
+Line 1109 
 for (;; ptr++)
          ketoffset = code - ket;
          }
+       /* The case of a zero minimum is special because of the need to stick
+       OP_BRAZERO in front of it, and because the group appears once in the
+       data, whereas in other cases it appears the minimum number of times. For
+       this reason, it is simplest to treat this case separately, as otherwise
+       the code gets far too mess. There are several special subcases when the
+       minimum is zero. */
+       if (repeat_min == 0)
+         {
+         /* If the maximum is also zero, we just omit the group from the output
+         altogether. */
+         if (repeat_max == 0)
+           {
+           code = previous;
+           previous = NULL;
+           break;
+           }
+         /* If the maximum is 1 or unlimited, we just have to stick in the
+         BRAZERO and do no more at this point. */
+         if (repeat_max <= 1)
+           {
+           memmove(previous+1, previous, len);
+           code++;
+           *previous++ = OP_BRAZERO + repeat_type;
+           }
+         /* If the maximum is greater than 1 and limited, we have to replicate
+         in a nested fashion, sticking OP_BRAZERO before each set of brackets.
+         The first one has to be handled carefully because it's the original
+         copy, which has to be moved up. The remainder can be handled by code
+         that is common with the non-zero minimum case below. We just have to
+         adjust the value or repeat_max, since one less copy is required. */
+         else
+           {
+           int offset;
+           memmove(previous+4, previous, len);
+           code += 4;
+           *previous++ = OP_BRAZERO + repeat_type;
+           *previous++ = OP_BRA;
+           /* We chain together the bracket offset fields that have to be
+           filled in later when the ends of the brackets are reached. */
+           offset = (bralink == NULL)? 0 : previous - bralink;
+           bralink = previous;
+           *previous++ = offset >> 8;
+           *previous++ = offset & 255;
+           }
+         repeat_max--;
+         }
+       /* If the minimum is greater than zero, replicate the group as many
+       times as necessary, and adjust the maximum to the number of subsequent
+       copies that we need. */
+       else
+         {
+         for (i = 1; i < repeat_min; i++)
+           {
+           memcpy(code, previous, len);
+           code += len;
+           }
+         if (repeat_max > 0) repeat_max -= repeat_min;
+         }
+       /* This code is common to both the zero and non-zero minimum cases. If
+       the maximum is limited, it replicates the group in a nested fashion,
+       remembering the bracket starts on a stack. In the case of a zero minimum,
+       the first one was set up above. In all cases the repeat_max now specifies
+       the number of additional copies needed. */
+       if (repeat_max >= 0)
+         {
+         for (i = repeat_max - 1; i >= 0; i--)
+           {
+           *code++ = OP_BRAZERO + repeat_type;
+           /* All but the final copy start a new nesting, maintaining the
+           chain of brackets outstanding. */
+           if (i != 0)
+             {
+             int offset;
+             *code++ = OP_BRA;
+             offset = (bralink == NULL)? 0 : code - bralink;
+             bralink = code;
+             *code++ = offset >> 8;
+             *code++ = offset & 255;
+             }
+           memcpy(code, previous, len);
+           code += len;
+           }
+         /* Now chain through the pending brackets, and fill in their length
+         fields (which are holding the chain links pro tem). */
+         while (bralink != NULL)
+           {
+           int oldlinkoffset;
+           int offset = code - bralink + 1;
+           uschar *bra = code - offset;
+           oldlinkoffset = (bra[1] << 8) + bra[2];
+           bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
+           *code++ = OP_KET;
+           *code++ = bra[1] = offset >> 8;
+           *code++ = bra[2] = (offset & 255);
+           }
+         }
+       /* If the maximum is unlimited, set a repeater in the final copy. We
+       can't just offset backwards from the current code point, because we
+       don't know if there's been an options resetting after the ket. The
+       correct offset was computed above. */
+       else code[-ketoffset] = OP_KETRMAX + repeat_type;
+ #ifdef NEVER
        /* If the minimum is greater than zero, and the maximum is unlimited or
        equal to the minimum, the first copy remains where it is, and is
        replicated up to the minimum number of times. This case includes the +
-Line 1150 
 for (;; ptr++)
+Line 1280 
 for (;; ptr++)
        correct offset was computed above. */
        if (repeat_max == -1) code[-ketoffset] = OP_KETRMAX + repeat_type;
+ #endif
        }
      /* Else there's some kind of shambles */
-Line 1684 
 all of whose alternatives start with OP_
+Line 1817 
 all of whose alternatives start with OP_
  it's anchored. However, if this is a multiline pattern, then only OP_SOD
  counts, since OP_CIRC can match in the middle.
- A branch is also implicitly anchored if it starts with .* because that will try
+ A branch is also implicitly anchored if it starts with .* and DOTALL is set,
- the rest of the pattern at all possible matching points, so there is no point
+ because that will try the rest of the pattern at all possible matching points,
- trying them again.
+ so there is no point trying them again.
  Arguments:
    code       points to start of expression (the bracket)
-Line 1704 
 do {
+Line 1837 
 do {
     register int op = *scode;
     if (op >= OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
       { if (!is_anchored(scode, options)) return FALSE; }
-    else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR)
+    else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR) &&
+             (*options & PCRE_DOTALL) != 0)
       { if (scode[1] != OP_ANY) return FALSE; }
     else if (op != OP_SOD &&
             ((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
-Line 1718 
 return TRUE;
+Line 1852 
 return TRUE;
  /*************************************************
- *     Check for start with \n line expression    *
+ *         Check for starting with ^ or .*        *
  *************************************************/
- /* This is called for multiline expressions to try to find out if every branch
+ /* This is called to find out if every branch starts with ^ or .* so that
- starts with ^ so that "first char" processing can be done to speed things up.
+ "first char" processing can be done to speed things up in multiline
+ matching and for non-DOTALL patterns that start with .* (which must start at
+ the beginning or after \n).
  Argument:  points to start of expression (the bracket)
  Returns:   TRUE or FALSE
-Line 1736 
 do {
+Line 1872 
 do {
     register int op = *scode;
     if (op >= OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
       { if (!is_startline(scode)) return FALSE; }
+    else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR)
+      { if (scode[1] != OP_ANY) return FALSE; }
     else if (op != OP_CIRC) return FALSE;
     code += (code[1] << 8) + code[2];
     }
-Line 2268 
 while ((c = *(++ptr)) != 0)
+Line 2406 
 while ((c = *(++ptr)) != 0)
        else if (c == '+') { maxval = -1; ptr++; }
        else if (c == '?') { minval = 0; ptr++; }
-       /* If there is a minimum > 1 we have to replicate up to minval-1 times;
+       /* If the minimum is zero, we have to allow for an OP_BRAZERO before the
-       if there is a limited maximum we have to replicate up to maxval-1 times
+       group, and if the maximum is greater than zero, we have to replicate
-       and allow for a BRAZERO item before each optional copy, as we also have
+       maxval-1 times; each replication acquires an OP_BRAZERO plus a nesting
-       to do before the first copy if the minimum is zero. */
+       bracket set - hence the 7. */
-       if (minval == 0) length++;
+       if (minval == 0)
-         else if (minval > 1) length += (minval - 1) * duplength;
+         {
-       if (maxval > minval) length += (maxval - minval) * (duplength + 1);
+         length++;
+         if (maxval > 0) length += (maxval - 1) * (duplength + 7);
+         }
+       /* When the minimum is greater than zero, 1 we have to replicate up to
+       minval-1 times, with no additions required in the copies. Then, if
+       there is a limited maximum we have to replicate up to maxval-1 times
+       allowing for a BRAZERO item before each optional copy and nesting
+       brackets for all but one of the optional copies. */
+       else
+         {
+         length += (minval - 1) * duplength;
+         if (maxval > minval)   /* Need this test as maxval=-1 means no limit */
+           length += (maxval - minval) * (duplength + 7) - 6;
+         }
        }
      continue;
-Line 2398 
 if (*errorptr != NULL)
+Line 2551 
 if (*errorptr != NULL)
    return NULL;
    }
- /* If the anchored option was not passed, set flag if we can determine that it
+ /* If the anchored option was not passed, set flag if we can determine that the
- is anchored by virtue of ^ characters or \A or anything else. Otherwise, see if
+ pattern is anchored by virtue of ^ characters or \A or anything else (such as
- we can determine what the first character has to be, because that speeds up
+ starting with .* when DOTALL is set).
- unanchored matches no end. In the case of multiline matches, an alternative is
- to set the PCRE_STARTLINE flag if all branches start with ^. */
+ Otherwise, see if we can determine what the first character has to be, because
+ that speeds up unanchored matches no end. If not, see if we can set the
+ PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
+ start with ^. and also when all branches start with .* for non-DOTALL matches.
+ */
  if ((options & PCRE_ANCHORED) == 0)
    {
-Line 2771 
 for (;;)
+Line 2928 
 for (;;)
      int number = op - OP_BRA;
      int offset = number << 1;
-     DPRINTF(("start bracket %d\n", number));
+ #ifdef DEBUG
+     printf("start bracket %d subject=", number);
+     pchars(eptr, 16, TRUE, md);
+     printf("\n");
+ #endif
      if (offset < md->offset_max)
        {
-Line 4033 
 in the pattern. */
+Line 4194 
 in the pattern. */
  resetcount = 2 + re->top_bracket * 2;
  if (resetcount > offsetcount) resetcount = ocount;
+ /* Reset the working variable associated with each extraction. These should
+ never be used unless previously set, but they get saved and restored, and so we
+ initialize them to avoid reading uninitialized locations. */
+ if (match_block.offset_vector != NULL)
+   {
+   register int *iptr = match_block.offset_vector + ocount;
+   register int *iend = iptr - resetcount/2 + 1;
+   while (--iptr >= iend) *iptr = -1;
+   }
  /* Set up the first character to match, if available. The first_char value is
  never set for an anchored regular expression, but the anchoring may be forced
  at run time, so we have to test for anchoring. The first char may be unset for

 Legend:



Removed from v.25
 


changed lines


 
Added in v.33
 Legend:



Removed from v.25
 


changed lines


 
Added in v.33
-Removed from v.25
+Added in v.33

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12