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

Diff of /code/trunk/pcre_compile.c

Parent Directory | Revision Log | View Patch Patch

-revision 787 by ph10,
Fri Dec  2 10:39:32 2011 UTC
+revision 788 by ph10,
Tue Dec  6 15:38:01 2011 UTC
 Line 88 
 so this number is very generous.
  The same workspace is used during the second, actual compile phase for
  remembering forward references to groups so that they can be filled in at the
  end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE
  is 4 there is plenty of room for most patterns. However, the memory can get
  filled up by repetitions of forward references, for example patterns like
  /(?1){0,1999}(b)/, and one user did hit the limit. The code has been changed so
  that the workspace is expanded using malloc() in this situation. The value
  below is therefore a minimum, and we put a maximum on it for safety. The
  minimum is now also defined in terms of LINK_SIZE so that the use of malloc()
  kicks in at the same number of forward references in all cases. */
  #define COMPILE_WORK_SIZE (2048*LINK_SIZE)
 Line 419 
 static const char error_texts[] =
    "\\k is not followed by a braced, angle-bracketed, or quoted name\0"
    /* 70 */
    "internal error: unknown opcode in find_fixedlength()\0"
    "\\N is not supported in a class\0"
    "too many forward references\0"
    ;
  /* Table to identify digits and hex digits. This is used when compiling
 Line 592 
 return s;
  *           Expand the workspace                 *
  *************************************************/
  /* This function is called during the second compiling phase, if the number of
  forward references fills the existing workspace, which is originally a block on
  the stack. A larger block is obtained from malloc() unless the ultimate limit
  has been reached or the increase will be rather small.
  Argument: pointer to the compile data block
 Line 617 
 if (newspace == NULL) return ERR21;
  memcpy(newspace, cd->start_workspace, cd->workspace_size);
  cd->hwm = (uschar *)newspace + (cd->hwm - cd->start_workspace);
  if (cd->workspace_size > COMPILE_WORK_SIZE)
    (pcre_free)((void *)cd->start_workspace);
  cd->start_workspace = newspace;
  cd->workspace_size = newsize;
 Line 1749 
 for (;;)
      cc++;
      break;
      /* The single-byte matcher isn't allowed. This only happens in UTF-8 mode;
      otherwise \C is coded as OP_ALLANY. */
      case OP_ANYBYTE:
 Line 3377 
 for (;; ptr++)
  #ifdef PCRE_DEBUG
      if (code > cd->hwm) cd->hwm = code;                 /* High water info */
  #endif
      if (code > cd->start_workspace + cd->workspace_size -
          WORK_SIZE_SAFETY_MARGIN)                       /* Check for overrun */
        {
        *errorcodeptr = ERR52;
 Line 3428 
 for (;; ptr++)
    /* In the real compile phase, just check the workspace used by the forward
    reference list. */
    else if (cd->hwm > cd->start_workspace + cd->workspace_size -
             WORK_SIZE_SAFETY_MARGIN)
      {
      *errorcodeptr = ERR52;
 Line 3822 
 for (;; ptr++)
          else if (-c == ESC_N)            /* \N is not supported in a class */
            {
            *errorcodeptr = ERR71;
            goto FAILED;
            }
          else if (-c == ESC_Q)            /* Handle start of quoted string */
            {
            if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
 Line 4480 
 for (;; ptr++)
      past, but it no longer happens for non-repeated recursions. In fact, the
      repeated ones could be re-implemented independently so as not to need this,
      but for the moment we rely on the code for repeating groups. */
      if (*previous == OP_RECURSE)
        {
        memmove(previous + 1 + LINK_SIZE, previous, 1 + LINK_SIZE);
 Line 4932 
 for (;; ptr++)
              }
            /* This is compiling for real. If there is a set first byte for
            the group, and we have not yet set a "required byte", set it. Make
            sure there is enough workspace for copying forward references before
            doing the copy. */
            else
 Line 4945 
 for (;; ptr++)
                uschar *hc;
                uschar *this_hwm = cd->hwm;
                memcpy(code, previous, len);
                while (cd->hwm > cd->start_workspace + cd->workspace_size -
                       WORK_SIZE_SAFETY_MARGIN - (this_hwm - save_hwm))
                  {
 Line 4954 
 for (;; ptr++)
                  *errorcodeptr = expand_workspace(cd);
                  if (*errorcodeptr != 0) goto FAILED;
                  save_hwm = (uschar *)cd->start_workspace + save_offset;
                  this_hwm = (uschar *)cd->start_workspace + this_offset;
                  }
                for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
                  {
                  PUT(cd->hwm, 0, GET(hc, 0) + len);
 Line 4986 
 for (;; ptr++)
          add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
          paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type is
          a 64-bit integer type when available, otherwise double. */
          if (lengthptr != NULL && repeat_max > 0)
            {
            int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
 Line 5024 
 for (;; ptr++)
              }
            memcpy(code, previous, len);
            /* Ensure there is enough workspace for forward references before
            copying them. */
            while (cd->hwm > cd->start_workspace + cd->workspace_size -
                   WORK_SIZE_SAFETY_MARGIN - (this_hwm - save_hwm))
              {
 Line 5036 
 for (;; ptr++)
              *errorcodeptr = expand_workspace(cd);
              if (*errorcodeptr != 0) goto FAILED;
              save_hwm = (uschar *)cd->start_workspace + save_offset;
              this_hwm = (uschar *)cd->start_workspace + this_offset;
              }
            for (hc = save_hwm; hc < this_hwm; hc += LINK_SIZE)
              {
              PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));
 Line 5069 
 for (;; ptr++)
        ONCE brackets can be converted into non-capturing brackets, as the
        behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to
        deal with possessive ONCEs specially.
        Otherwise, when we are doing the actual compile phase, check to see
        whether this group is one that could match an empty string. If so,
        convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so
        that runtime checking can be done. [This check is also applied to ONCE
        groups at runtime, but in a different way.]
        Then, if the quantifier was possessive and the bracket is not a
        conditional, we convert the BRA code to the POS form, and the KET code to
        KETRPOS. (It turns out to be convenient at runtime to detect this kind of
        subpattern at both the start and at the end.) The use of special opcodes
        makes it possible to reduce greatly the stack usage in pcre_exec(). If
        the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO.
        Then, if the minimum number of matches is 1 or 0, cancel the possessive
        flag so that the default action below, of wrapping everything inside
        atomic brackets, does not happen. When the minimum is greater than 1,
        there will be earlier copies of the group, and so we still have to wrap
        the whole thing. */
        else
 Line 5095 
 for (;; ptr++)
          uschar *bracode = ketcode - GET(ketcode, 1);
          /* Convert possessive ONCE brackets to non-capturing */
          if ((*bracode == OP_ONCE || *bracode == OP_ONCE_NC) &&
              possessive_quantifier) *bracode = OP_BRA;
          /* For non-possessive ONCE brackets, all we need to do is to
          set the KET. */
          if (*bracode == OP_ONCE || *bracode == OP_ONCE_NC)
            *ketcode = OP_KETRMAX + repeat_type;
          /* Handle non-ONCE brackets and possessive ONCEs (which have been
          converted to non-capturing above). */
          else
            {
            /* In the compile phase, check for empty string matching. */
            if (lengthptr == NULL)
              {
              uschar *scode = bracode;
 Line 5126 
 for (;; ptr++)
                }
              while (*scode == OP_ALT);
              }
            /* Handle possessive quantifiers. */
            if (possessive_quantifier)
 Line 5135 
 for (;; ptr++)
              repeated non-capturing bracket, because we have not invented POS
              versions of the COND opcodes. Because we are moving code along, we
              must ensure that any pending recursive references are updated. */
              if (*bracode == OP_COND || *bracode == OP_SCOND)
                {
                int nlen = (int)(code - bracode);
 Line 5148 
 for (;; ptr++)
                *code++ = OP_KETRPOS;
                PUTINC(code, 0, nlen);
                PUT(bracode, 1, nlen);
                }
              /* For non-COND brackets, we modify the BRA code and use KETRPOS. */
              else
                {
                *bracode += 1;              /* Switch to xxxPOS opcodes */
                *ketcode = OP_KETRPOS;
                }
              /* If the minimum is zero, mark it as possessive, then unset the
              possessive flag when the minimum is 0 or 1. */
              if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO;
              if (repeat_min < 2) possessive_quantifier = FALSE;
              }
            /* Non-possessive quantifier */
            else *ketcode = OP_KETRMAX + repeat_type;
            }
          }
 Line 6056 
 for (;; ptr++)
                /* Fudge the value of "called" so that when it is inserted as an
                offset below, what it actually inserted is the reference number
                of the group. Then remember the forward reference. */
                called = cd->start_code + recno;
                if (cd->hwm >= cd->start_workspace + cd->workspace_size -
                    WORK_SIZE_SAFETY_MARGIN)
                  {
                  *errorcodeptr = expand_workspace(cd);
                  if (*errorcodeptr != 0) goto FAILED;
                  }
                PUTINC(cd->hwm, 0, (int)(code + 1 - cd->start_code));
                }
 Line 6085 
 for (;; ptr++)
              }
            /* Insert the recursion/subroutine item. It does not have a set first
            byte (relevant if it is repeated, because it will then be wrapped
            with ONCE brackets). */
            *code = OP_RECURSE;
            PUT(code, 1, (int)(called - cd->start_code));
            code += 1 + LINK_SIZE;
            groupsetfirstbyte = FALSE;
            }
          /* Can't determine a first byte now */
 Line 6575 
 for (;; ptr++)
  #endif
          /* In non-UTF-8 mode, we turn \C into OP_ALLANY instead of OP_ANYBYTE
          so that it works in DFA mode and in lookbehinds. */
            {
            previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;
            *code++ = (!utf8 && c == -ESC_C)? OP_ALLANY : -c;
            }
 Line 7314 
 compile_data *cd = &compile_block;
  computing the amount of memory that is needed. Compiled items are thrown away
  as soon as possible, so that a fairly large buffer should be sufficient for
  this purpose. The same space is used in the second phase for remembering where
  to fill in forward references to subpatterns. That may overflow, in which case
  new memory is obtained from malloc(). */
  uschar cworkspace[COMPILE_WORK_SIZE];
 Line 7620 
 if debugging, leave the test till after
  if (code - codestart > length) errorcode = ERR23;
  #endif
  /* Fill in any forward references that are required. There may be repeated
  references; optimize for them, as searching a large regex takes time. */
  if (cd->hwm > cd->start_workspace)
    {
    int prev_recno = -1;
    const uschar *groupptr = NULL;
    while (errorcode == 0 && cd->hwm > cd->start_workspace)
      {
 Line 7634 
 if (cd->hwm > cd->start_workspace)
      offset = GET(cd->hwm, 0);
      recno = GET(codestart, offset);
      if (recno != prev_recno)
        {
        groupptr = _pcre_find_bracket(codestart, utf8, recno);
        prev_recno = recno;
        }
      if (groupptr == NULL) errorcode = ERR53;
        else PUT(((uschar *)codestart), offset, (int)(groupptr - codestart));
      }
    }
  /* If the workspace had to be expanded, free the new memory. */
  if (cd->workspace_size > COMPILE_WORK_SIZE)
    (pcre_free)((void *)cd->start_workspace);
  /* Give an error if there's back reference to a non-existent capturing
  subpattern. */

 Legend:



Removed from v.787
 


changed lines


 
Added in v.788
 Legend:



Removed from v.787
 


changed lines


 
Added in v.788
-Removed from v.787
+Added in v.788

	ViewVC Help
Powered by ViewVC 1.1.5