/[pcre]/code/branches/pcre16/pcre_study.c

Diff of /code/branches/pcre16/pcre_study.c

Parent Directory | Revision Log | View Patch Patch

-revision 460 by ph10,
Sun Oct  4 09:21:39 2009 UTC
+revision 461 by ph10,
Mon Oct  5 10:59:35 2009 UTC
 Line 60 
 enum { SSB_FAIL, SSB_DONE, SSB_CONTINUE
  *************************************************/
  /* Scan a parenthesized group and compute the minimum length of subject that
  is needed to match it. This is a lower bound; it does not mean there is a
  string of that length that matches. In UTF8 mode, the result is in characters
  rather than bytes.
  Arguments:
    code       pointer to start of group (the bracket)
    startcode  pointer to start of the whole pattern
    options    the compiling options
  Returns:   the minimum length
             -1 if \C was encountered
             -2 internal error (missing capturing bracket)
  */
  static int
 Line 91 
 branch, check the length against that of
  for (;;)
    {
    int d, min;
    uschar *cs, *ce;
    register int op = *cc;
    switch (op)
      {
      case OP_CBRA:
      case OP_SCBRA:
      case OP_BRA:
      case OP_SBRA:
      case OP_ONCE:
      case OP_COND:
      case OP_SCOND:
      d = find_minlength(cc, startcode, options);
      if (d < 0) return d;
      branchlength += d;
 Line 119 
 for (;;)
      case OP_KETRMAX:
      case OP_KETRMIN:
      case OP_END:
      if (length < 0 || (!had_recurse && branchlength < length))
        length = branchlength;
      if (*cc != OP_ALT) return length;
      cc += 1 + LINK_SIZE;
      branchlength = 0;
      had_recurse = FALSE;
      break;
      /* Skip over assertive subpatterns */
 Line 156 
 for (;;)
      case OP_WORD_BOUNDARY:
      cc += _pcre_OP_lengths[*cc];
      break;
      /* Skip over a subpattern that has a {0} or {0,x} quantifier */
      case OP_BRAZERO:
      case OP_BRAMINZERO:
      case OP_SKIPZERO:
      cc += _pcre_OP_lengths[*cc];
      do cc += GET(cc, 1); while (*cc == OP_ALT);
 Line 184 
 for (;;)
      if (utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
  #endif
      break;
      case OP_TYPEPLUS:
      case OP_TYPEMINPLUS:
      case OP_TYPEPOSPLUS:
      branchlength++;
      cc += (cc[1] == OP_PROP || cc[1] == OP_NOTPROP)? 4 : 2;
      break;
 Line 196 
 for (;;)
      need to skip over a multibyte character in UTF8 mode.  */
      case OP_EXACT:
      case OP_NOTEXACT:
      branchlength += GET2(cc,1);
      cc += 4;
  #ifdef SUPPORT_UTF8
 Line 225 
 for (;;)
      case OP_ANY:
      case OP_ALLANY:
      case OP_EXTUNI:
      case OP_HSPACE:
      case OP_NOT_HSPACE:
      case OP_VSPACE:
      case OP_NOT_VSPACE:
      branchlength++;
      cc++;
      break;
      /* "Any newline" might match two characters */
      case OP_ANYNL:
      branchlength += 2;
      cc++;
      break;
      /* The single-byte matcher means we can't proceed in UTF-8 mode */
 Line 248 
 for (;;)
  #endif
      branchlength++;
      cc++;
      break;
      /* For repeated character types, we have to test for \p and \P, which have
      an extra two bytes of parameters. */
 Line 287 
 for (;;)
        case OP_CRPLUS:
        case OP_CRMINPLUS:
        branchlength++;
        /* Fall through */
        case OP_CRSTAR:
        case OP_CRMINSTAR:
        case OP_CRQUERY:
        case OP_CRMINQUERY:
        cc++;
        break;
        case OP_CRRANGE:
        case OP_CRMINRANGE:
        branchlength += GET2(cc,1);
        cc += 5;
        break;
        default:
        branchlength++;
        break;
        }
      break;
      /* Backreferences and subroutine calls are treated in the same way: we find
      the minimum length for the subpattern. A recursion, however, causes an
      a flag to be set that causes the length of this branch to be ignored. The
      logic is that a recursion can only make sense if there is another
      alternation that stops the recursing. That will provide the minimum length
      (when no recursion happens). A backreference within the group that it is
      referencing behaves in the same way. */
      case OP_REF:
      ce = cs = (uschar *)_pcre_find_bracket(startcode, utf8, GET2(cc, 1));
      if (cs == NULL) return -2;
 Line 323 
 for (;;)
      if (cc > cs && cc < ce)
        {
        d = 0;
        had_recurse = TRUE;
        }
      else d = find_minlength(cs, startcode, options);
      cc += 3;
      /* Handle repeated back references */
      switch (*cc)
        {
        case OP_CRSTAR:
 Line 339 
 for (;;)
        min = 0;
        cc++;
        break;
        case OP_CRRANGE:
        case OP_CRMINRANGE:
        min = GET2(cc, 1);
        cc += 5;
        break;
        default:
        min = 1;
        break;
        }
      branchlength += min * d;
      break;
      case OP_RECURSE:
      cs = ce = (uschar *)startcode + GET(cc, 1);
      if (cs == NULL) return -2;
      do ce += GET(ce, 1); while (*ce == OP_ALT);
      if (cc > cs && cc < ce)
        had_recurse = TRUE;
      else
        branchlength += find_minlength(cs, startcode, options);
      cc += 1 + LINK_SIZE;
      break;
      /* Anything else does not or need not match a character. We can get the
      item's length from the table, but for those that can match zero occurrences
      of a character, we must take special action for UTF-8 characters. */
      case OP_UPTO:
      case OP_NOTUPTO:
      case OP_MINUPTO:
      case OP_NOTMINUPTO:
      case OP_POSUPTO:
      case OP_STAR:
      case OP_MINSTAR:
      case OP_NOTMINSTAR:
      case OP_POSSTAR:
      case OP_NOTPOSSTAR:
      case OP_QUERY:
      case OP_MINQUERY:
      case OP_NOTMINQUERY:
      case OP_POSQUERY:
      case OP_NOTPOSQUERY:
      cc += _pcre_OP_lengths[op];
  #ifdef SUPPORT_UTF8
      if (utf8 && cc[-1] >= 0xc0) cc += _pcre_utf8_table4[cc[-1] & 0x3f];
  #endif
      break;
      /* For the record, these are the opcodes that are matched by "default":
      OP_ACCEPT, OP_CLOSE, OP_COMMIT, OP_FAIL, OP_PRUNE, OP_SET_SOM, OP_SKIP,
      OP_THEN. */
      default:
      cc += _pcre_OP_lengths[op];
      break;
 Line 885 
 code = (uschar *)re + re->name_table_off
    (re->name_count * re->name_entry_size);
  /* For an anchored pattern, or an unanchored pattern that has a first char, or
  a multiline pattern that matches only at "line starts", there is no point in
  seeking a list of starting bytes. */
  if ((re->options & PCRE_ANCHORED) == 0 &&
      (re->flags & (PCRE_FIRSTSET|PCRE_STARTLINE)) == 0)
    {
    /* Set the character tables in the block that is passed around */
    tables = re->tables;
    if (tables == NULL)
      (void)pcre_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES,
      (void *)(&tables));
    compile_block.lcc = tables + lcc_offset;
    compile_block.fcc = tables + fcc_offset;
    compile_block.cbits = tables + cbits_offset;
    compile_block.ctypes = tables + ctypes_offset;
    /* See if we can find a fixed set of initial characters for the pattern. */
    memset(start_bits, 0, 32 * sizeof(uschar));
    bits_set = set_start_bits(code, start_bits,
      (re->options & PCRE_CASELESS) != 0, (re->options & PCRE_UTF8) != 0,
      &compile_block) == SSB_DONE;
    }
  /* Find the minimum length of subject string. */
  min = find_minlength(code, code, re->options);
 Line 947 
 if (bits_set)
    study->flags |= PCRE_STUDY_MAPPED;
    memcpy(study->start_bits, start_bits, sizeof(start_bits));
    }
  if (min >= 0)
    {
    study->flags |= PCRE_STUDY_MINLEN;
    study->minlength = min;
    }
  return extra;
  }

 Legend:



Removed from v.460
 


changed lines


 
Added in v.461
 Legend:



Removed from v.460
 


changed lines


 
Added in v.461
-Removed from v.460
+Added in v.461

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12