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

Diff of /code/trunk/pcre_dfa_exec.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 361 by ph10, Thu Jul 10 16:03:28 2008 UTC revision 459 by ph10, Sun Oct 4 09:21:39 2009 UTC
# Line 3  Line 3 
3  *************************************************/  *************************************************/
4    
5  /* PCRE is a library of functions to support regular expressions whose syntax  /* PCRE is a library of functions to support regular expressions whose syntax
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language (but see
7    below for why this module is different).
8    
9                         Written by Philip Hazel                         Written by Philip Hazel
10             Copyright (c) 1997-2008 University of Cambridge             Copyright (c) 1997-2009 University of Cambridge
11    
12  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
13  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 44  FSM). This is NOT Perl- compatible, but Line 45  FSM). This is NOT Perl- compatible, but
45  applications. */  applications. */
46    
47    
48    /* NOTE ABOUT PERFORMANCE: A user of this function sent some code that improved
49    the performance of his patterns greatly. I could not use it as it stood, as it
50    was not thread safe, and made assumptions about pattern sizes. Also, it caused
51    test 7 to loop, and test 9 to crash with a segfault.
52    
53    The issue is the check for duplicate states, which is done by a simple linear
54    search up the state list. (Grep for "duplicate" below to find the code.) For
55    many patterns, there will never be many states active at one time, so a simple
56    linear search is fine. In patterns that have many active states, it might be a
57    bottleneck. The suggested code used an indexing scheme to remember which states
58    had previously been used for each character, and avoided the linear search when
59    it knew there was no chance of a duplicate. This was implemented when adding
60    states to the state lists.
61    
62    I wrote some thread-safe, not-limited code to try something similar at the time
63    of checking for duplicates (instead of when adding states), using index vectors
64    on the stack. It did give a 13% improvement with one specially constructed
65    pattern for certain subject strings, but on other strings and on many of the
66    simpler patterns in the test suite it did worse. The major problem, I think,
67    was the extra time to initialize the index. This had to be done for each call
68    of internal_dfa_exec(). (The supplied patch used a static vector, initialized
69    only once - I suspect this was the cause of the problems with the tests.)
70    
71    Overall, I concluded that the gains in some cases did not outweigh the losses
72    in others, so I abandoned this code. */
73    
74    
75    
76  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
77  #include "config.h"  #include "config.h"
78  #endif  #endif
# Line 60  applications. */ Line 89  applications. */
89  #define SP "                   "  #define SP "                   "
90    
91    
   
92  /*************************************************  /*************************************************
93  *      Code parameters and static tables         *  *      Code parameters and static tables         *
94  *************************************************/  *************************************************/
# Line 389  if (*first_op == OP_REVERSE) Line 417  if (*first_op == OP_REVERSE)
417        current_subject - start_subject : max_back;        current_subject - start_subject : max_back;
418      current_subject -= gone_back;      current_subject -= gone_back;
419      }      }
420    
421      /* Save the earliest consulted character */
422    
423      if (current_subject < md->start_used_ptr)
424        md->start_used_ptr = current_subject;
425    
426    /* Now we can process the individual branches. */    /* Now we can process the individual branches. */
427    
# Line 454  for (;;) Line 487  for (;;)
487    int i, j;    int i, j;
488    int clen, dlen;    int clen, dlen;
489    unsigned int c, d;    unsigned int c, d;
490      int forced_fail = 0;
491      int reached_end = 0;
492    
493    /* Make the new state list into the active state list and empty the    /* Make the new state list into the active state list and empty the
494    new state list. */    new state list. */
# Line 511  for (;;) Line 546  for (;;)
546      stateblock *current_state = active_states + i;      stateblock *current_state = active_states + i;
547      const uschar *code;      const uschar *code;
548      int state_offset = current_state->offset;      int state_offset = current_state->offset;
549      int count, codevalue;      int count, codevalue, rrc;
550    
551  #ifdef DEBUG  #ifdef DEBUG
552      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);
# Line 543  for (;;) Line 578  for (;;)
578          }          }
579        }        }
580    
581      /* Check for a duplicate state with the same count, and skip if found. */      /* Check for a duplicate state with the same count, and skip if found.
582        See the note at the head of this module about the possibility of improving
583        performance here. */
584    
585      for (j = 0; j < i; j++)      for (j = 0; j < i; j++)
586        {        {
# Line 610  for (;;) Line 647  for (;;)
647  /* ========================================================================== */  /* ========================================================================== */
648        /* Reached a closing bracket. If not at the end of the pattern, carry        /* Reached a closing bracket. If not at the end of the pattern, carry
649        on with the next opcode. Otherwise, unless we have an empty string and        on with the next opcode. Otherwise, unless we have an empty string and
650        PCRE_NOTEMPTY is set, save the match data, shifting up all previous        PCRE_NOTEMPTY is set, or PCRE_NOTEMPTY_ATSTART is set and we are at the
651          start of the subject, save the match data, shifting up all previous
652        matches so we always have the longest first. */        matches so we always have the longest first. */
653    
654        case OP_KET:        case OP_KET:
# Line 624  for (;;) Line 662  for (;;)
662            ADD_ACTIVE(state_offset - GET(code, 1), 0);            ADD_ACTIVE(state_offset - GET(code, 1), 0);
663            }            }
664          }          }
665        else if (ptr > current_subject || (md->moptions & PCRE_NOTEMPTY) == 0)        else
666          {          {
667          if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;          reached_end++;    /* Count branches that reach the end */
668            else if (match_count > 0 && ++match_count * 2 >= offsetcount)          if (ptr > current_subject ||
669              match_count = 0;              ((md->moptions & PCRE_NOTEMPTY) == 0 &&
670          count = ((match_count == 0)? offsetcount : match_count * 2) - 2;                ((md->moptions & PCRE_NOTEMPTY_ATSTART) == 0 ||
671          if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));                  current_subject > start_subject + md->start_offset)))
672          if (offsetcount >= 2)            {
673            {            if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;
674            offsets[0] = current_subject - start_subject;              else if (match_count > 0 && ++match_count * 2 >= offsetcount)
675            offsets[1] = ptr - start_subject;                match_count = 0;
676            DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,            count = ((match_count == 0)? offsetcount : match_count * 2) - 2;
677              offsets[1] - offsets[0], current_subject));            if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));
678            }            if (offsetcount >= 2)
679          if ((md->moptions & PCRE_DFA_SHORTEST) != 0)              {
680            {              offsets[0] = current_subject - start_subject;
681            DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"              offsets[1] = ptr - start_subject;
682              "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel,              DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,
683              match_count, rlevel*2-2, SP));                offsets[1] - offsets[0], current_subject));
684            return match_count;              }
685            }            if ((md->moptions & PCRE_DFA_SHORTEST) != 0)
686                {
687                DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"
688                  "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel,
689                  match_count, rlevel*2-2, SP));
690                return match_count;
691                }
692              }
693          }          }
694        break;        break;
695    
# Line 757  for (;;) Line 802  for (;;)
802        if ((md->moptions & PCRE_NOTEOL) == 0)        if ((md->moptions & PCRE_NOTEOL) == 0)
803          {          {
804          if (clen == 0 ||          if (clen == 0 ||
805              (IS_NEWLINE(ptr) &&              ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&
806                 ((ims & PCRE_MULTILINE) != 0 || ptr == end_subject - md->nllen)                 ((ims & PCRE_MULTILINE) != 0 || ptr == end_subject - md->nllen)
807              ))              ))
808            { ADD_ACTIVE(state_offset + 1, 0); }            { ADD_ACTIVE(state_offset + 1, 0); }
# Line 794  for (;;) Line 839  for (;;)
839          if (ptr > start_subject)          if (ptr > start_subject)
840            {            {
841            const uschar *temp = ptr - 1;            const uschar *temp = ptr - 1;
842              if (temp < md->start_used_ptr) md->start_used_ptr = temp;
843  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
844            if (utf8) BACKCHAR(temp);            if (utf8) BACKCHAR(temp);
845  #endif  #endif
# Line 802  for (;;) Line 848  for (;;)
848            }            }
849          else left_word = 0;          else left_word = 0;
850    
851          if (clen > 0) right_word = c < 256 && (ctypes[c] & ctype_word) != 0;          if (clen > 0)
852            else right_word = 0;            right_word = c < 256 && (ctypes[c] & ctype_word) != 0;
853            else              /* This is a fudge to ensure that if this is the */
854              {               /* last item in the pattern, we don't count it as */
855              reached_end--;  /* reached, thus disabling a partial match. */
856              right_word = 0;
857              }
858    
859          if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY))          if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY))
860            { ADD_ACTIVE(state_offset + 1, 0); }            { ADD_ACTIVE(state_offset + 1, 0); }
# Line 2157  for (;;) Line 2208  for (;;)
2208    
2209  /* ========================================================================== */  /* ========================================================================== */
2210        /* These are the opcodes for fancy brackets of various kinds. We have        /* These are the opcodes for fancy brackets of various kinds. We have
2211        to use recursion in order to handle them. The "always failing" assersion        to use recursion in order to handle them. The "always failing" assertion
2212        (?!) is optimised when compiling to OP_FAIL, so we have to support that,        (?!) is optimised to OP_FAIL when compiling, so we have to support that,
2213        though the other "backtracking verbs" are not supported. */        though the other "backtracking verbs" are not supported. */
2214    
2215        case OP_FAIL:        case OP_FAIL:
2216          forced_fail++;    /* Count FAILs for multiple states */
2217        break;        break;
2218    
2219        case OP_ASSERT:        case OP_ASSERT:
# Line 2200  for (;;) Line 2252  for (;;)
2252          {          {
2253          int local_offsets[1000];          int local_offsets[1000];
2254          int local_workspace[1000];          int local_workspace[1000];
2255          int condcode = code[LINK_SIZE+1];          int codelink = GET(code, 1);
2256            int condcode;
2257    
2258            /* Because of the way auto-callout works during compile, a callout item
2259            is inserted between OP_COND and an assertion condition. This does not
2260            happen for the other conditions. */
2261    
2262            if (code[LINK_SIZE+1] == OP_CALLOUT)
2263              {
2264              rrc = 0;
2265              if (pcre_callout != NULL)
2266                {
2267                pcre_callout_block cb;
2268                cb.version          = 1;   /* Version 1 of the callout block */
2269                cb.callout_number   = code[LINK_SIZE+2];
2270                cb.offset_vector    = offsets;
2271                cb.subject          = (PCRE_SPTR)start_subject;
2272                cb.subject_length   = end_subject - start_subject;
2273                cb.start_match      = current_subject - start_subject;
2274                cb.current_position = ptr - start_subject;
2275                cb.pattern_position = GET(code, LINK_SIZE + 3);
2276                cb.next_item_length = GET(code, 3 + 2*LINK_SIZE);
2277                cb.capture_top      = 1;
2278                cb.capture_last     = -1;
2279                cb.callout_data     = md->callout_data;
2280                if ((rrc = (*pcre_callout)(&cb)) < 0) return rrc;   /* Abandon */
2281                }
2282              if (rrc > 0) break;                      /* Fail this thread */
2283              code += _pcre_OP_lengths[OP_CALLOUT];    /* Skip callout data */
2284              }
2285    
2286            condcode = code[LINK_SIZE+1];
2287    
2288          /* Back reference conditions are not supported */          /* Back reference conditions are not supported */
2289    
2290          if (condcode == OP_CREF) return PCRE_ERROR_DFA_UCOND;          if (condcode == OP_CREF || condcode == OP_NCREF)
2291              return PCRE_ERROR_DFA_UCOND;
2292    
2293          /* The DEFINE condition is always false */          /* The DEFINE condition is always false */
2294    
2295          if (condcode == OP_DEF)          if (condcode == OP_DEF)
2296            {            { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
           ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0);  
           }  
2297    
2298          /* The only supported version of OP_RREF is for the value RREF_ANY,          /* The only supported version of OP_RREF is for the value RREF_ANY,
2299          which means "test if in any recursion". We can't test for specifically          which means "test if in any recursion". We can't test for specifically
2300          recursed groups. */          recursed groups. */
2301    
2302          else if (condcode == OP_RREF)          else if (condcode == OP_RREF || condcode == OP_NRREF)
2303            {            {
2304            int value = GET2(code, LINK_SIZE+2);            int value = GET2(code, LINK_SIZE+2);
2305            if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;            if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;
2306            if (recursing > 0) { ADD_ACTIVE(state_offset + LINK_SIZE + 4, 0); }            if (recursing > 0)
2307              else { ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0); }              { ADD_ACTIVE(state_offset + LINK_SIZE + 4, 0); }
2308              else { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
2309            }            }
2310    
2311          /* Otherwise, the condition is an assertion */          /* Otherwise, the condition is an assertion */
# Line 2252  for (;;) Line 2335  for (;;)
2335                  (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))                  (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))
2336              { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }              { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }
2337            else            else
2338              { ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0); }              { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
2339            }            }
2340          }          }
2341        break;        break;
# Line 2404  for (;;) Line 2487  for (;;)
2487        /* Handle callouts */        /* Handle callouts */
2488    
2489        case OP_CALLOUT:        case OP_CALLOUT:
2490          rrc = 0;
2491        if (pcre_callout != NULL)        if (pcre_callout != NULL)
2492          {          {
         int rrc;  
2493          pcre_callout_block cb;          pcre_callout_block cb;
2494          cb.version          = 1;   /* Version 1 of the callout block */          cb.version          = 1;   /* Version 1 of the callout block */
2495          cb.callout_number   = code[1];          cb.callout_number   = code[1];
# Line 2421  for (;;) Line 2504  for (;;)
2504          cb.capture_last     = -1;          cb.capture_last     = -1;
2505          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
2506          if ((rrc = (*pcre_callout)(&cb)) < 0) return rrc;   /* Abandon */          if ((rrc = (*pcre_callout)(&cb)) < 0) return rrc;   /* Abandon */
         if (rrc == 0) { ADD_ACTIVE(state_offset + 2 + 2*LINK_SIZE, 0); }  
2507          }          }
2508          if (rrc == 0)
2509            { ADD_ACTIVE(state_offset + _pcre_OP_lengths[OP_CALLOUT], 0); }
2510        break;        break;
2511    
2512    
# Line 2438  for (;;) Line 2522  for (;;)
2522    /* We have finished the processing at the current subject character. If no    /* We have finished the processing at the current subject character. If no
2523    new states have been set for the next character, we have found all the    new states have been set for the next character, we have found all the
2524    matches that we are going to find. If we are at the top level and partial    matches that we are going to find. If we are at the top level and partial
2525    matching has been requested, check for appropriate conditions. */    matching has been requested, check for appropriate conditions. The "forced_
2526      fail" variable counts the number of (*F) encountered for the character. If it
2527      is equal to the original active_count (saved in workspace[1]) it means that
2528      (*F) was found on every active state. In this case we don't want to give a
2529      partial match. */
2530    
2531    if (new_count <= 0)    if (new_count <= 0)
2532      {      {
2533      if (match_count < 0 &&                     /* No matches found */      if (rlevel == 1 &&                               /* Top level, and */
2534          rlevel == 1 &&                         /* Top level match function */          reached_end != workspace[1] &&               /* Not all reached end */
2535          (md->moptions & PCRE_PARTIAL) != 0 &&  /* Want partial matching */          forced_fail != workspace[1] &&               /* Not all forced fail & */
2536          ptr >= end_subject &&                  /* Reached end of subject */          (                                            /* either... */
2537          ptr > current_subject)                 /* Matched non-empty string */          (md->moptions & PCRE_PARTIAL_HARD) != 0      /* Hard partial */
2538            ||                                           /* or... */
2539            ((md->moptions & PCRE_PARTIAL_SOFT) != 0 &&  /* Soft partial and */
2540             match_count < 0)                            /* no matches */
2541            ) &&                                         /* And... */
2542            ptr >= end_subject &&                     /* Reached end of subject */
2543            ptr > current_subject)                    /* Matched non-empty string */
2544        {        {
2545        if (offsetcount >= 2)        if (offsetcount >= 2)
2546          {          {
2547          offsets[0] = current_subject - start_subject;          offsets[0] = md->start_used_ptr - start_subject;
2548          offsets[1] = end_subject - start_subject;          offsets[1] = end_subject - start_subject;
2549          }          }
2550        match_count = PCRE_ERROR_PARTIAL;        match_count = PCRE_ERROR_PARTIAL;
# Line 2558  if (extra_data != NULL) Line 2652  if (extra_data != NULL)
2652    if ((flags & PCRE_EXTRA_TABLES) != 0)    if ((flags & PCRE_EXTRA_TABLES) != 0)
2653      md->tables = extra_data->tables;      md->tables = extra_data->tables;
2654    }    }
2655    
2656  /* Check that the first field in the block is the magic number. If it is not,  /* Check that the first field in the block is the magic number. If it is not,
2657  test for a regex that was compiled on a host of opposite endianness. If this is  test for a regex that was compiled on a host of opposite endianness. If this is
2658  the case, flipped values are put in internal_re and internal_study if there was  the case, flipped values are put in internal_re and internal_study if there was
# Line 2592  md->start_code = (const uschar *)argumen Line 2686  md->start_code = (const uschar *)argumen
2686      re->name_table_offset + re->name_count * re->name_entry_size;      re->name_table_offset + re->name_count * re->name_entry_size;
2687  md->start_subject = (const unsigned char *)subject;  md->start_subject = (const unsigned char *)subject;
2688  md->end_subject = end_subject;  md->end_subject = end_subject;
2689    md->start_offset = start_offset;
2690  md->moptions = options;  md->moptions = options;
2691  md->poptions = re->options;  md->poptions = re->options;
2692    
# Line 2614  switch ((((options & PCRE_NEWLINE_BITS) Line 2709  switch ((((options & PCRE_NEWLINE_BITS)
2709           PCRE_NEWLINE_BITS)           PCRE_NEWLINE_BITS)
2710    {    {
2711    case 0: newline = NEWLINE; break;   /* Compile-time default */    case 0: newline = NEWLINE; break;   /* Compile-time default */
2712    case PCRE_NEWLINE_CR: newline = '\r'; break;    case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
2713    case PCRE_NEWLINE_LF: newline = '\n'; break;    case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
2714    case PCRE_NEWLINE_CR+    case PCRE_NEWLINE_CR+
2715         PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;         PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
2716    case PCRE_NEWLINE_ANY: newline = -1; break;    case PCRE_NEWLINE_ANY: newline = -1; break;
2717    case PCRE_NEWLINE_ANYCRLF: newline = -2; break;    case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
2718    default: return PCRE_ERROR_BADNEWLINE;    default: return PCRE_ERROR_BADNEWLINE;
# Line 2696  if (!anchored) Line 2791  if (!anchored)
2791      }      }
2792    else    else
2793      {      {
2794      if (startline && study != NULL &&      if (!startline && study != NULL &&
2795           (study->options & PCRE_STUDY_MAPPED) != 0)           (study->flags & PCRE_STUDY_MAPPED) != 0)
2796        start_bits = study->start_bits;        start_bits = study->start_bits;
2797      }      }
2798    }    }
# Line 2713  if ((re->flags & PCRE_REQCHSET) != 0) Line 2808  if ((re->flags & PCRE_REQCHSET) != 0)
2808    }    }
2809    
2810  /* Call the main matching function, looping for a non-anchored regex after a  /* Call the main matching function, looping for a non-anchored regex after a
2811  failed match. Unless restarting, optimize by moving to the first match  failed match. If not restarting, perform certain optimizations at the start of
2812  character if possible, when not anchored. Then unless wanting a partial match,  a match. */
 check for a required later character. */  
2813    
2814  for (;;)  for (;;)
2815    {    {
# Line 2725  for (;;) Line 2819  for (;;)
2819      {      {
2820      const uschar *save_end_subject = end_subject;      const uschar *save_end_subject = end_subject;
2821    
2822      /* Advance to a unique first char if possible. If firstline is TRUE, the      /* If firstline is TRUE, the start of the match is constrained to the first
2823      start of the match is constrained to the first line of a multiline string.      line of a multiline string. Implement this by temporarily adjusting
2824      Implement this by temporarily adjusting end_subject so that we stop      end_subject so that we stop scanning at a newline. If the match fails at
2825      scanning at a newline. If the match fails at the newline, later code breaks      the newline, later code breaks this loop. */
     this loop. */  
2826    
2827      if (firstline)      if (firstline)
2828        {        {
2829        const uschar *t = current_subject;        USPTR t = current_subject;
2830    #ifdef SUPPORT_UTF8
2831          if (utf8)
2832            {
2833            while (t < md->end_subject && !IS_NEWLINE(t))
2834              {
2835              t++;
2836              while (t < end_subject && (*t & 0xc0) == 0x80) t++;
2837              }
2838            }
2839          else
2840    #endif
2841        while (t < md->end_subject && !IS_NEWLINE(t)) t++;        while (t < md->end_subject && !IS_NEWLINE(t)) t++;
2842        end_subject = t;        end_subject = t;
2843        }        }
2844    
2845      if (first_byte >= 0)      /* There are some optimizations that avoid running the match if a known
2846        {      starting point is not found. However, there is an option that disables
2847        if (first_byte_caseless)      these, for testing and for ensuring that all callouts do actually occur. */
         while (current_subject < end_subject &&  
                lcc[*current_subject] != first_byte)  
           current_subject++;  
       else  
         while (current_subject < end_subject && *current_subject != first_byte)  
           current_subject++;  
       }  
2848    
2849      /* Or to just after a linebreak for a multiline match if possible */      if ((options & PCRE_NO_START_OPTIMIZE) == 0)
   
     else if (startline)  
2850        {        {
2851        if (current_subject > md->start_subject + start_offset)        /* Advance to a known first byte. */
         {  
         while (current_subject < end_subject && !WAS_NEWLINE(current_subject))  
           current_subject++;  
2852    
2853          /* If we have just passed a CR and the newline option is ANY or        if (first_byte >= 0)
         ANYCRLF, and we are now at a LF, advance the match position by one more  
         character. */  
   
         if (current_subject[-1] == '\r' &&  
              (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&  
              current_subject < end_subject &&  
              *current_subject == '\n')  
           current_subject++;  
         }  
       }  
   
     /* Or to a non-unique first char after study */  
   
     else if (start_bits != NULL)  
       {  
       while (current_subject < end_subject)  
2854          {          {
2855          register unsigned int c = *current_subject;          if (first_byte_caseless)
2856          if ((start_bits[c/8] & (1 << (c&7))) == 0) current_subject++;            while (current_subject < end_subject &&
2857            else break;                   lcc[*current_subject] != first_byte)
2858                current_subject++;
2859            else
2860              while (current_subject < end_subject &&
2861                     *current_subject != first_byte)
2862                current_subject++;
2863          }          }
       }  
   
     /* Restore fudged end_subject */  
2864    
2865      end_subject = save_end_subject;        /* Or to just after a linebreak for a multiline match if possible */
     }  
   
   /* 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 must be  
   later in the subject; otherwise the test starts at the match point. This  
   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  
   versions makes it go faster, as does using an autoincrement and backing off  
   on a match.  
   
   HOWEVER: when the subject string is very, very long, searching to its end can  
   take a long time, and give bad performance on quite ordinary 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.  
   
   ALSO: this processing is disabled when partial matching is requested.  
   */  
   
   if (req_byte >= 0 &&  
       end_subject - current_subject < REQ_BYTE_MAX &&  
       (options & PCRE_PARTIAL) == 0)  
     {  
     register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);  
2866    
2867      /* We don't need to repeat the search if we haven't yet reached the        else if (startline)
     place we found it at last time. */  
   
     if (p > req_byte_ptr)  
       {  
       if (req_byte_caseless)  
2868          {          {
2869          while (p < end_subject)          if (current_subject > md->start_subject + start_offset)
2870            {            {
2871            register int pp = *p++;  #ifdef SUPPORT_UTF8
2872            if (pp == req_byte || pp == req_byte2) { p--; break; }            if (utf8)
2873                {
2874                while (current_subject < end_subject &&
2875                       !WAS_NEWLINE(current_subject))
2876                  {
2877                  current_subject++;
2878                  while(current_subject < end_subject &&
2879                        (*current_subject & 0xc0) == 0x80)
2880                    current_subject++;
2881                  }
2882                }
2883              else
2884    #endif
2885              while (current_subject < end_subject && !WAS_NEWLINE(current_subject))
2886                current_subject++;
2887    
2888              /* If we have just passed a CR and the newline option is ANY or
2889              ANYCRLF, and we are now at a LF, advance the match position by one
2890              more character. */
2891    
2892              if (current_subject[-1] == CHAR_CR &&
2893                   (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
2894                   current_subject < end_subject &&
2895                   *current_subject == CHAR_NL)
2896                current_subject++;
2897            }            }
2898          }          }
2899        else  
2900          /* Or to a non-unique first char after study */
2901    
2902          else if (start_bits != NULL)
2903          {          {
2904          while (p < end_subject)          while (current_subject < end_subject)
2905            {            {
2906            if (*p++ == req_byte) { p--; break; }            register unsigned int c = *current_subject;
2907              if ((start_bits[c/8] & (1 << (c&7))) == 0) current_subject++;
2908                else break;
2909            }            }
2910          }          }
2911          }
2912    
2913        /* If we can't find the required character, break the matching loop,      /* Restore fudged end_subject */
       which will cause a return or PCRE_ERROR_NOMATCH. */  
   
       if (p >= end_subject) break;  
2914    
2915        /* If we have found the required character, save the point where we      end_subject = save_end_subject;
       found it, so that we don't search again next time round the loop if  
       the start hasn't passed this character yet. */  
2916    
2917        req_byte_ptr = p;      /* The following two optimizations are disabled for partial matching or if
2918        disabling is explicitly requested (and of course, by the test above, this
2919        code is not obeyed when restarting after a partial match). */
2920    
2921        if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&
2922            (options & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) == 0)
2923          {
2924          /* If the pattern was studied, a minimum subject length may be set. This
2925          is a lower bound; no actual string of that length may actually match the
2926          pattern. Although the value is, strictly, in characters, we treat it as
2927          bytes to avoid spending too much time in this optimization. */
2928    
2929          if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
2930              end_subject - current_subject < study->minlength)
2931            return PCRE_ERROR_NOMATCH;
2932    
2933          /* If req_byte is set, we know that that character must appear in the
2934          subject for the match to succeed. If the first character is set, req_byte
2935          must be later in the subject; otherwise the test starts at the match
2936          point. This optimization can save a huge amount of work in patterns with
2937          nested unlimited repeats that aren't going to match. Writing separate
2938          code for cased/caseless versions makes it go faster, as does using an
2939          autoincrement and backing off on a match.
2940    
2941          HOWEVER: when the subject string is very, very long, searching to its end
2942          can take a long time, and give bad performance on quite ordinary
2943          patterns. This showed up when somebody was matching /^C/ on a 32-megabyte
2944          string... so we don't do this when the string is sufficiently long. */
2945    
2946          if (req_byte >= 0 && end_subject - current_subject < REQ_BYTE_MAX)
2947            {
2948            register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);
2949    
2950            /* We don't need to repeat the search if we haven't yet reached the
2951            place we found it at last time. */
2952    
2953            if (p > req_byte_ptr)
2954              {
2955              if (req_byte_caseless)
2956                {
2957                while (p < end_subject)
2958                  {
2959                  register int pp = *p++;
2960                  if (pp == req_byte || pp == req_byte2) { p--; break; }
2961                  }
2962                }
2963              else
2964                {
2965                while (p < end_subject)
2966                  {
2967                  if (*p++ == req_byte) { p--; break; }
2968                  }
2969                }
2970    
2971              /* If we can't find the required character, break the matching loop,
2972              which will cause a return or PCRE_ERROR_NOMATCH. */
2973    
2974              if (p >= end_subject) break;
2975    
2976              /* If we have found the required character, save the point where we
2977              found it, so that we don't search again next time round the loop if
2978              the start hasn't passed this character yet. */
2979    
2980              req_byte_ptr = p;
2981              }
2982            }
2983        }        }
2984      }      }   /* End of optimizations that are done when not restarting */
2985    
2986    /* OK, now we can do the business */    /* OK, now we can do the business */
2987    
2988      md->start_used_ptr = current_subject;
2989    
2990    rc = internal_dfa_exec(    rc = internal_dfa_exec(
2991      md,                                /* fixed match data */      md,                                /* fixed match data */
2992      md->start_code,                    /* this subexpression's code */      md->start_code,                    /* this subexpression's code */
# Line 2879  for (;;) Line 3021  for (;;)
3021    not contain any explicit matches for \r or \n, and the newline option is CRLF    not contain any explicit matches for \r or \n, and the newline option is CRLF
3022    or ANY or ANYCRLF, advance the match position by one more character. */    or ANY or ANYCRLF, advance the match position by one more character. */
3023    
3024    if (current_subject[-1] == '\r' &&    if (current_subject[-1] == CHAR_CR &&
3025        current_subject < end_subject &&        current_subject < end_subject &&
3026        *current_subject == '\n' &&        *current_subject == CHAR_NL &&
3027        (re->flags & PCRE_HASCRORLF) == 0 &&        (re->flags & PCRE_HASCRORLF) == 0 &&
3028          (md->nltype == NLTYPE_ANY ||          (md->nltype == NLTYPE_ANY ||
3029           md->nltype == NLTYPE_ANYCRLF ||           md->nltype == NLTYPE_ANYCRLF ||

Legend:
Removed from v.361  
changed lines
  Added in v.459

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12