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

Diff of /code/trunk/pcre_dfa_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 442 by ph10,
Fri Sep 11 10:21:02 2009 UTC
+revision 455 by ph10,
Sat Sep 26 19:12:32 2009 UTC
 Line 2651 
 if (extra_data != NULL)
    if ((flags & PCRE_EXTRA_TABLES) != 0)
      md->tables = extra_data->tables;
    }
  /* Check that the first field in the block is the magic number. If it is not,
  test for a regex that was compiled on a host of opposite endianness. If this is
  the case, flipped values are put in internal_re and internal_study if there was
 Line 2790 
 if (!anchored)
      }
    else
      {
-     if (startline && study != NULL &&
+     if (!startline && study != NULL &&
-          (study->options & PCRE_STUDY_MAPPED) != 0)
+          (study->flags & PCRE_STUDY_MAPPED) != 0)
        start_bits = study->start_bits;
      }
    }
 Line 2842 
 for (;;)
        }
      /* There are some optimizations that avoid running the match if a known
-     starting point is not found, or if a known later character is not present.
+     starting point is not found. However, there is an option that disables
-     However, there is an option that disables these, for testing and for
+     these, for testing and for ensuring that all callouts do actually occur. */
-     ensuring that all callouts do actually occur. */
      if ((options & PCRE_NO_START_OPTIMIZE) == 0)
        {
        /* Advance to a known first byte. */
        if (first_byte >= 0)
-Line 2914 
 for (;;)
+Line 2912 
 for (;;)
      /* Restore fudged end_subject */
      end_subject = save_end_subject;
-     }
-   /* If req_byte is set, we know that that character must appear in the subject
+     /* The following two optimizations are disabled for partial matching or if
-   for the match to succeed. If the first character is set, req_byte must be
+     disabling is explicitly requested (and of course, by the test above, this
-   later in the subject; otherwise the test starts at the match point. This
+     code is not obeyed when restarting after a partial match). */
-   optimization can save a huge amount of work in patterns with nested unlimited
-   repeats that aren't going to match. Writing separate code for cased/caseless
+     if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&
-   versions makes it go faster, as does using an autoincrement and backing off
+         (options & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) == 0)
-   on a match.
+       {
+       /* If the pattern was studied, a minimum subject length may be set. This
-   HOWEVER: when the subject string is very, very long, searching to its end can
+       is a lower bound; no actual string of that length may actually match the
-   take a long time, and give bad performance on quite ordinary patterns. This
+       pattern. Although the value is, strictly, in characters, we treat it as
-   showed up when somebody was matching /^C/ on a 32-megabyte string... so we
+       bytes to avoid spending too much time in this optimization. */
-   don't do this when the string is sufficiently long.
+       if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
-   ALSO: this processing is disabled when partial matching is requested, and can
+           end_subject - current_subject < study->minlength)
-   also be explicitly deactivated. Furthermore, we have to disable when
+         return PCRE_ERROR_NOMATCH;
-   restarting after a partial match, because the required character may have
-   already been matched. */
+       /* If req_byte is set, we know that that character must appear in the
+       subject for the match to succeed. If the first character is set, req_byte
-   if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&
+       must be later in the subject; otherwise the test starts at the match
-       req_byte >= 0 &&
+       point. This optimization can save a huge amount of work in patterns with
-       end_subject - current_subject < REQ_BYTE_MAX &&
+       nested unlimited repeats that aren't going to match. Writing separate
-       (options & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT|PCRE_DFA_RESTART)) == 0)
+       code for cased/caseless versions makes it go faster, as does using an
-     {
+       autoincrement and backing off on a match.
-     register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);
+       HOWEVER: when the subject string is very, very long, searching to its end
-     /* We don't need to repeat the search if we haven't yet reached the
+       can take a long time, and give bad performance on quite ordinary
-     place we found it at last time. */
+       patterns. This showed up when somebody was matching /^C/ on a 32-megabyte
+       string... so we don't do this when the string is sufficiently long. */
-     if (p > req_byte_ptr)
-       {
+       if (req_byte >= 0 && end_subject - current_subject < REQ_BYTE_MAX)
-       if (req_byte_caseless)
          {
-         while (p < end_subject)
+         register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);
+         /* We don't need to repeat the search if we haven't yet reached the
+         place we found it at last time. */
+         if (p > req_byte_ptr)
            {
-           register int pp = *p++;
+           if (req_byte_caseless)
-           if (pp == req_byte || pp == req_byte2) { p--; break; }
+             {
-           }
+             while (p < end_subject)
-         }
+               {
-       else
+               register int pp = *p++;
-         {
+               if (pp == req_byte || pp == req_byte2) { p--; break; }
-         while (p < end_subject)
+               }
-           {
+             }
-           if (*p++ == req_byte) { p--; break; }
+           else
+             {
+             while (p < end_subject)
+               {
+               if (*p++ == req_byte) { p--; break; }
+               }
+             }
+           /* If we can't find the required character, break the matching loop,
+           which will cause a return or PCRE_ERROR_NOMATCH. */
+           if (p >= end_subject) break;
+           /* If we have found the required character, save the point where we
+           found it, so that we don't search again next time round the loop if
+           the start hasn't passed this character yet. */
+           req_byte_ptr = p;
            }
          }
-       /* If we can't find the required character, break the matching loop,
-       which will cause a return or PCRE_ERROR_NOMATCH. */
-       if (p >= end_subject) break;
-       /* If we have found the required character, save the point where we
-       found it, so that we don't search again next time round the loop if
-       the start hasn't passed this character yet. */
-       req_byte_ptr = p;
        }
-     }
+     }   /* End of optimizations that are done when not restarting */
    /* OK, now we can do the business */

 Legend:



Removed from v.442
 


changed lines


 
Added in v.455
 Legend:



Removed from v.442
 


changed lines


 
Added in v.455
-Removed from v.442
+Added in v.455

	ViewVC Help
Powered by ViewVC 1.1.5