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

Diff of /code/trunk/pcre.c

Parent Directory | Revision Log | View Patch Patch

-revision 27 by nigel,
Sat Feb 24 21:38:49 2007 UTC
+revision 35 by nigel,
Sat Feb 24 21:39:05 2007 UTC
 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 1657 
 for (;;)
+Line 1790 
 for (;;)
      code += 2;
      break;
+     case OP_WORD_BOUNDARY:
+     case OP_NOT_WORD_BOUNDARY:
+     code++;
+     break;
      case OP_ASSERT_NOT:
      case OP_ASSERTBACK:
      case OP_ASSERTBACK_NOT:
-Line 1684 
 all of whose alternatives start with OP_
+Line 1822 
 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 1842 
 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 1857 
 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 1877 
 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 2411 
 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 2556 
 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 2933 
 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 3952 
 Arguments:
+Line 4118 
 Arguments:
    external_extra  points to "hints" from pcre_study() or is NULL
    subject         points to the subject string
    length          length of subject string (may contain binary zeros)
+   start_offset    where to start in the subject string
    options         option bits
    offsets         points to a vector of ints to be filled in with offsets
    offsetcount     the number of elements in the vector
-Line 3964 
 Returns:          > 0 => success; value
+Line 4131 
 Returns:          > 0 => success; value
  int
  pcre_exec(const pcre *external_re, const pcre_extra *external_extra,
-   const char *subject, int length, int options, int *offsets, int offsetcount)
+   const char *subject, int length, int start_offset, int options, int *offsets,
+   int offsetcount)
  {
  int resetcount, ocount;
  int first_char = -1;
  int ims = 0;
  match_data match_block;
  const uschar *start_bits = NULL;
- const uschar *start_match = (const uschar *)subject;
+ const uschar *start_match = (const uschar *)subject + start_offset;
  const uschar *end_subject;
  const real_pcre *re = (const real_pcre *)external_re;
  const real_pcre_extra *extra = (const real_pcre_extra *)external_extra;
-Line 4063 
 if (!anchored)
+Line 4231 
 if (!anchored)
          start_bits = extra->start_bits;
    }
- /* Loop for unanchored matches; for anchored regexps the loop runs just once. */
+ /* Loop for unanchored matches; for anchored regexs the loop runs just once. */
  do
    {

 Legend:



Removed from v.27
 


changed lines


 
Added in v.35
 Legend:



Removed from v.27
 


changed lines


 
Added in v.35
-Removed from v.27
+Added in v.35

	ViewVC Help
Powered by ViewVC 1.1.5