/[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 426 by ph10, Wed Aug 26 15:38:32 2009 UTC revision 553 by ph10, Fri Oct 22 15:57:50 2010 UTC
# Line 7  and semantics are as close as possible t Line 7  and semantics are as close as possible t
7  below for why this module is different).  below for why this module is different).
8    
9                         Written by Philip Hazel                         Written by Philip Hazel
10             Copyright (c) 1997-2009 University of Cambridge             Copyright (c) 1997-2010 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 45  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 78  never stored, so we push them well clear Line 106  never stored, so we push them well clear
106    
107    
108  /* This table identifies those opcodes that are followed immediately by a  /* This table identifies those opcodes that are followed immediately by a
109  character that is to be tested in some way. This makes is possible to  character that is to be tested in some way. This makes it possible to
110  centralize the loading of these characters. In the case of Type * etc, the  centralize the loading of these characters. In the case of Type * etc, the
111  "character" is the opcode for \D, \d, \S, \s, \W, or \w, which will always be a  "character" is the opcode for \D, \d, \S, \s, \W, or \w, which will always be a
112  small value. ***NOTE*** If the start of this table is modified, the two tables  small value. Non-zero values in the table are the offsets from the opcode where
113  that follow must also be modified. */  the character is to be found. ***NOTE*** If the start of this table is
114    modified, the three tables that follow must also be modified. */
115    
116  static const uschar coptable[] = {  static const uschar coptable[] = {
117    0,                             /* End                                    */    0,                             /* End                                    */
118    0, 0, 0, 0, 0,                 /* \A, \G, \K, \B, \b                     */    0, 0, 0, 0, 0,                 /* \A, \G, \K, \B, \b                     */
119    0, 0, 0, 0, 0, 0,              /* \D, \d, \S, \s, \W, \w                 */    0, 0, 0, 0, 0, 0,              /* \D, \d, \S, \s, \W, \w                 */
120    0, 0, 0,                       /* Any, AllAny, Anybyte                   */    0, 0, 0,                       /* Any, AllAny, Anybyte                   */
121    0, 0, 0,                       /* NOTPROP, PROP, EXTUNI                  */    0, 0,                          /* \P, \p                                 */
122    0, 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */    0, 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */
123      0,                             /* \X                                     */
124    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */
125    1,                             /* Char                                   */    1,                             /* Char                                   */
126    1,                             /* Charnc                                 */    1,                             /* Charnc                                 */
# Line 127  static const uschar coptable[] = { Line 157  static const uschar coptable[] = {
157    0,                             /* Reverse                                */    0,                             /* Reverse                                */
158    0, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */    0, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */
159    0, 0, 0,                       /* SBRA, SCBRA, SCOND                     */    0, 0, 0,                       /* SBRA, SCBRA, SCOND                     */
160    0,                             /* CREF                                   */    0, 0,                          /* CREF, NCREF                            */
161    0,                             /* RREF                                   */    0, 0,                          /* RREF, NRREF                            */
162      0,                             /* DEF                                    */
163      0, 0,                          /* BRAZERO, BRAMINZERO                    */
164      0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */
165      0, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG,        */
166      0, 0, 0, 0, 0                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */
167    };
168    
169    /* This table identifies those opcodes that inspect a character. It is used to
170    remember the fact that a character could have been inspected when the end of
171    the subject is reached. ***NOTE*** If the start of this table is modified, the
172    two tables that follow must also be modified. */
173    
174    static const uschar poptable[] = {
175      0,                             /* End                                    */
176      0, 0, 0, 1, 1,                 /* \A, \G, \K, \B, \b                     */
177      1, 1, 1, 1, 1, 1,              /* \D, \d, \S, \s, \W, \w                 */
178      1, 1, 1,                       /* Any, AllAny, Anybyte                   */
179      1, 1,                          /* \P, \p                                 */
180      1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */
181      1,                             /* \X                                     */
182      0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */
183      1,                             /* Char                                   */
184      1,                             /* Charnc                                 */
185      1,                             /* not                                    */
186      /* Positive single-char repeats                                          */
187      1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
188      1, 1, 1,                       /* upto, minupto, exact                   */
189      1, 1, 1, 1,                    /* *+, ++, ?+, upto+                      */
190      /* Negative single-char repeats - only for chars < 256                   */
191      1, 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */
192      1, 1, 1,                       /* NOT upto, minupto, exact               */
193      1, 1, 1, 1,                    /* NOT *+, ++, ?+, upto+                  */
194      /* Positive type repeats                                                 */
195      1, 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */
196      1, 1, 1,                       /* Type upto, minupto, exact              */
197      1, 1, 1, 1,                    /* Type *+, ++, ?+, upto+                 */
198      /* Character class & ref repeats                                         */
199      1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
200      1, 1,                          /* CRRANGE, CRMINRANGE                    */
201      1,                             /* CLASS                                  */
202      1,                             /* NCLASS                                 */
203      1,                             /* XCLASS - variable length               */
204      0,                             /* REF                                    */
205      0,                             /* RECURSE                                */
206      0,                             /* CALLOUT                                */
207      0,                             /* Alt                                    */
208      0,                             /* Ket                                    */
209      0,                             /* KetRmax                                */
210      0,                             /* KetRmin                                */
211      0,                             /* Assert                                 */
212      0,                             /* Assert not                             */
213      0,                             /* Assert behind                          */
214      0,                             /* Assert behind not                      */
215      0,                             /* Reverse                                */
216      0, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */
217      0, 0, 0,                       /* SBRA, SCBRA, SCOND                     */
218      0, 0,                          /* CREF, NCREF                            */
219      0, 0,                          /* RREF, NRREF                            */
220    0,                             /* DEF                                    */    0,                             /* DEF                                    */
221    0, 0,                          /* BRAZERO, BRAMINZERO                    */    0, 0,                          /* BRAZERO, BRAMINZERO                    */
222    0, 0, 0, 0,                    /* PRUNE, SKIP, THEN, COMMIT              */    0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */
223    0, 0, 0                        /* FAIL, ACCEPT, SKIPZERO                 */    0, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG,        */
224      0, 0, 0, 0, 0                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */
225  };  };
226    
227  /* These 2 tables allow for compact code for testing for \D, \d, \S, \s, \W,  /* These 2 tables allow for compact code for testing for \D, \d, \S, \s, \W,
# Line 170  typedef struct stateblock { Line 259  typedef struct stateblock {
259  #define INTS_PER_STATEBLOCK  (sizeof(stateblock)/sizeof(int))  #define INTS_PER_STATEBLOCK  (sizeof(stateblock)/sizeof(int))
260    
261    
262  #ifdef DEBUG  #ifdef PCRE_DEBUG
263  /*************************************************  /*************************************************
264  *             Print character string             *  *             Print character string             *
265  *************************************************/  *************************************************/
# Line 386  if (*first_op == OP_REVERSE) Line 475  if (*first_op == OP_REVERSE)
475    
476      {      {
477      gone_back = (current_subject - max_back < start_subject)?      gone_back = (current_subject - max_back < start_subject)?
478        current_subject - start_subject : max_back;        (int)(current_subject - start_subject) : max_back;
479      current_subject -= gone_back;      current_subject -= gone_back;
480      }      }
481    
482      /* Save the earliest consulted character */
483    
484      if (current_subject < md->start_used_ptr)
485        md->start_used_ptr = current_subject;
486    
487    /* Now we can process the individual branches. */    /* Now we can process the individual branches. */
488    
489    end_code = this_start_code;    end_code = this_start_code;
# Line 398  if (*first_op == OP_REVERSE) Line 492  if (*first_op == OP_REVERSE)
492      int back = GET(end_code, 2+LINK_SIZE);      int back = GET(end_code, 2+LINK_SIZE);
493      if (back <= gone_back)      if (back <= gone_back)
494        {        {
495        int bstate = end_code - start_code + 2 + 2*LINK_SIZE;        int bstate = (int)(end_code - start_code + 2 + 2*LINK_SIZE);
496        ADD_NEW_DATA(-bstate, 0, gone_back - back);        ADD_NEW_DATA(-bstate, 0, gone_back - back);
497        }        }
498      end_code += GET(end_code, 1);      end_code += GET(end_code, 1);
# Line 434  else Line 528  else
528        ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);        ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);
529      do      do
530        {        {
531        ADD_NEW(end_code - start_code + length, 0);        ADD_NEW((int)(end_code - start_code + length), 0);
532        end_code += GET(end_code, 1);        end_code += GET(end_code, 1);
533        length = 1 + LINK_SIZE;        length = 1 + LINK_SIZE;
534        }        }
# Line 454  for (;;) Line 548  for (;;)
548    int i, j;    int i, j;
549    int clen, dlen;    int clen, dlen;
550    unsigned int c, d;    unsigned int c, d;
551      int forced_fail = 0;
552      BOOL could_continue = FALSE;
553    
554    /* 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
555    new state list. */    new state list. */
# Line 467  for (;;) Line 563  for (;;)
563    workspace[0] ^= 1;              /* Remember for the restarting feature */    workspace[0] ^= 1;              /* Remember for the restarting feature */
564    workspace[1] = active_count;    workspace[1] = active_count;
565    
566  #ifdef DEBUG  #ifdef PCRE_DEBUG
567    printf("%.*sNext character: rest of subject = \"", rlevel*2-2, SP);    printf("%.*sNext character: rest of subject = \"", rlevel*2-2, SP);
568    pchars((uschar *)ptr, strlen((char *)ptr), stdout);    pchars((uschar *)ptr, strlen((char *)ptr), stdout);
569    printf("\"\n");    printf("\"\n");
# Line 513  for (;;) Line 609  for (;;)
609      int state_offset = current_state->offset;      int state_offset = current_state->offset;
610      int count, codevalue, rrc;      int count, codevalue, rrc;
611    
612  #ifdef DEBUG  #ifdef PCRE_DEBUG
613      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);
614      if (clen == 0) printf("EOL\n");      if (clen == 0) printf("EOL\n");
615        else if (c > 32 && c < 127) printf("'%c'\n", c);        else if (c > 32 && c < 127) printf("'%c'\n", c);
# Line 543  for (;;) Line 639  for (;;)
639          }          }
640        }        }
641    
642      /* 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.
643        See the note at the head of this module about the possibility of improving
644        performance here. */
645    
646      for (j = 0; j < i; j++)      for (j = 0; j < i; j++)
647        {        {
# Line 560  for (;;) Line 658  for (;;)
658      code = start_code + state_offset;      code = start_code + state_offset;
659      codevalue = *code;      codevalue = *code;
660    
661        /* If this opcode inspects a character, but we are at the end of the
662        subject, remember the fact for use when testing for a partial match. */
663    
664        if (clen == 0 && poptable[codevalue] != 0)
665          could_continue = TRUE;
666    
667      /* If this opcode is followed by an inline character, load it. It is      /* If this opcode is followed by an inline character, load it. It is
668      tempting to test for the presence of a subject character here, but that      tempting to test for the presence of a subject character here, but that
669      is wrong, because sometimes zero repetitions of the subject are      is wrong, because sometimes zero repetitions of the subject are
# Line 606  for (;;) Line 710  for (;;)
710    
711      switch (codevalue)      switch (codevalue)
712        {        {
713    /* ========================================================================== */
714          /* These cases are never obeyed. This is a fudge that causes a compile-
715          time error if the vectors coptable or poptable, which are indexed by
716          opcode, are not the correct length. It seems to be the only way to do
717          such a check at compile time, as the sizeof() operator does not work
718          in the C preprocessor. */
719    
720          case OP_TABLE_LENGTH:
721          case OP_TABLE_LENGTH +
722            ((sizeof(coptable) == OP_TABLE_LENGTH) &&
723             (sizeof(poptable) == OP_TABLE_LENGTH)):
724          break;
725    
726  /* ========================================================================== */  /* ========================================================================== */
727        /* 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
728        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
729        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
730          start of the subject, save the match data, shifting up all previous
731        matches so we always have the longest first. */        matches so we always have the longest first. */
732    
733        case OP_KET:        case OP_KET:
# Line 624  for (;;) Line 741  for (;;)
741            ADD_ACTIVE(state_offset - GET(code, 1), 0);            ADD_ACTIVE(state_offset - GET(code, 1), 0);
742            }            }
743          }          }
744        else if (ptr > current_subject || (md->moptions & PCRE_NOTEMPTY) == 0)        else
745          {          {
746          if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;          if (ptr > current_subject ||
747            else if (match_count > 0 && ++match_count * 2 >= offsetcount)              ((md->moptions & PCRE_NOTEMPTY) == 0 &&
748              match_count = 0;                ((md->moptions & PCRE_NOTEMPTY_ATSTART) == 0 ||
749          count = ((match_count == 0)? offsetcount : match_count * 2) - 2;                  current_subject > start_subject + md->start_offset)))
750          if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));            {
751          if (offsetcount >= 2)            if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;
752            {              else if (match_count > 0 && ++match_count * 2 >= offsetcount)
753            offsets[0] = current_subject - start_subject;                match_count = 0;
754            offsets[1] = ptr - start_subject;            count = ((match_count == 0)? offsetcount : match_count * 2) - 2;
755            DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,            if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));
756              offsets[1] - offsets[0], current_subject));            if (offsetcount >= 2)
757            }              {
758          if ((md->moptions & PCRE_DFA_SHORTEST) != 0)              offsets[0] = (int)(current_subject - start_subject);
759            {              offsets[1] = (int)(ptr - start_subject);
760            DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"              DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,
761              "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel,                offsets[1] - offsets[0], current_subject));
762              match_count, rlevel*2-2, SP));              }
763            return match_count;            if ((md->moptions & PCRE_DFA_SHORTEST) != 0)
764                {
765                DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"
766                  "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel,
767                  match_count, rlevel*2-2, SP));
768                return match_count;
769                }
770            }            }
771          }          }
772        break;        break;
# Line 655  for (;;) Line 778  for (;;)
778        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
779        case OP_ALT:        case OP_ALT:
780        do { code += GET(code, 1); } while (*code == OP_ALT);        do { code += GET(code, 1); } while (*code == OP_ALT);
781        ADD_ACTIVE(code - start_code, 0);        ADD_ACTIVE((int)(code - start_code), 0);
782        break;        break;
783    
784        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
# Line 663  for (;;) Line 786  for (;;)
786        case OP_SBRA:        case OP_SBRA:
787        do        do
788          {          {
789          ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);          ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
790          code += GET(code, 1);          code += GET(code, 1);
791          }          }
792        while (*code == OP_ALT);        while (*code == OP_ALT);
# Line 672  for (;;) Line 795  for (;;)
795        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
796        case OP_CBRA:        case OP_CBRA:
797        case OP_SCBRA:        case OP_SCBRA:
798        ADD_ACTIVE(code - start_code + 3 + LINK_SIZE,  0);        ADD_ACTIVE((int)(code - start_code + 3 + LINK_SIZE),  0);
799        code += GET(code, 1);        code += GET(code, 1);
800        while (*code == OP_ALT)        while (*code == OP_ALT)
801          {          {
802          ADD_ACTIVE(code - start_code + 1 + LINK_SIZE,  0);          ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE),  0);
803          code += GET(code, 1);          code += GET(code, 1);
804          }          }
805        break;        break;
# Line 687  for (;;) Line 810  for (;;)
810        ADD_ACTIVE(state_offset + 1, 0);        ADD_ACTIVE(state_offset + 1, 0);
811        code += 1 + GET(code, 2);        code += 1 + GET(code, 2);
812        while (*code == OP_ALT) code += GET(code, 1);        while (*code == OP_ALT) code += GET(code, 1);
813        ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);        ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
814        break;        break;
815    
816        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
817        case OP_SKIPZERO:        case OP_SKIPZERO:
818        code += 1 + GET(code, 2);        code += 1 + GET(code, 2);
819        while (*code == OP_ALT) code += GET(code, 1);        while (*code == OP_ALT) code += GET(code, 1);
820        ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);        ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
821        break;        break;
822    
823        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
# Line 708  for (;;) Line 831  for (;;)
831    
832        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
833        case OP_EOD:        case OP_EOD:
834        if (ptr >= end_subject) { ADD_ACTIVE(state_offset + 1, 0); }        if (ptr >= end_subject)
835            {
836            if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
837              could_continue = TRUE;
838            else { ADD_ACTIVE(state_offset + 1, 0); }
839            }
840        break;        break;
841    
842        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
# Line 748  for (;;) Line 876  for (;;)
876    
877        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
878        case OP_EODN:        case OP_EODN:
879        if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - md->nllen))        if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
880            could_continue = TRUE;
881          else if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - md->nllen))
882          { ADD_ACTIVE(state_offset + 1, 0); }          { ADD_ACTIVE(state_offset + 1, 0); }
883        break;        break;
884    
# Line 756  for (;;) Line 886  for (;;)
886        case OP_DOLL:        case OP_DOLL:
887        if ((md->moptions & PCRE_NOTEOL) == 0)        if ((md->moptions & PCRE_NOTEOL) == 0)
888          {          {
889          if (clen == 0 ||          if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
890              could_continue = TRUE;
891            else if (clen == 0 ||
892              ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&              ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&
893                 ((ims & PCRE_MULTILINE) != 0 || ptr == end_subject - md->nllen)                 ((ims & PCRE_MULTILINE) != 0 || ptr == end_subject - md->nllen)
894              ))              ))
# Line 794  for (;;) Line 926  for (;;)
926          if (ptr > start_subject)          if (ptr > start_subject)
927            {            {
928            const uschar *temp = ptr - 1;            const uschar *temp = ptr - 1;
929              if (temp < md->start_used_ptr) md->start_used_ptr = temp;
930  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
931            if (utf8) BACKCHAR(temp);            if (utf8) BACKCHAR(temp);
932  #endif  #endif
933            GETCHARTEST(d, temp);            GETCHARTEST(d, temp);
934    #ifdef SUPPORT_UCP
935              if ((md->poptions & PCRE_UCP) != 0)
936                {
937                if (d == '_') left_word = TRUE; else
938                  {
939                  int cat = UCD_CATEGORY(d);
940                  left_word = (cat == ucp_L || cat == ucp_N);
941                  }
942                }
943              else
944    #endif
945            left_word = d < 256 && (ctypes[d] & ctype_word) != 0;            left_word = d < 256 && (ctypes[d] & ctype_word) != 0;
946            }            }
947          else left_word = 0;          else left_word = FALSE;
948    
949          if (clen > 0) right_word = c < 256 && (ctypes[c] & ctype_word) != 0;          if (clen > 0)
950            else right_word = 0;            {
951    #ifdef SUPPORT_UCP
952              if ((md->poptions & PCRE_UCP) != 0)
953                {
954                if (c == '_') right_word = TRUE; else
955                  {
956                  int cat = UCD_CATEGORY(c);
957                  right_word = (cat == ucp_L || cat == ucp_N);
958                  }
959                }
960              else
961    #endif
962              right_word = c < 256 && (ctypes[c] & ctype_word) != 0;
963              }
964            else right_word = FALSE;
965    
966          if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY))          if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY))
967            { ADD_ACTIVE(state_offset + 1, 0); }            { ADD_ACTIVE(state_offset + 1, 0); }
# Line 830  for (;;) Line 988  for (;;)
988            break;            break;
989    
990            case PT_LAMP:            case PT_LAMP:
991            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
992                   prop->chartype == ucp_Lt;
993            break;            break;
994    
995            case PT_GC:            case PT_GC:
# Line 845  for (;;) Line 1004  for (;;)
1004            OK = prop->script == code[2];            OK = prop->script == code[2];
1005            break;            break;
1006    
1007              /* These are specials for combination cases. */
1008    
1009              case PT_ALNUM:
1010              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1011                   _pcre_ucp_gentype[prop->chartype] == ucp_N;
1012              break;
1013    
1014              case PT_SPACE:    /* Perl space */
1015              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1016                   c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1017              break;
1018    
1019              case PT_PXSPACE:  /* POSIX space */
1020              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1021                   c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1022                   c == CHAR_FF || c == CHAR_CR;
1023              break;
1024    
1025              case PT_WORD:
1026              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1027                   _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1028                   c == CHAR_UNDERSCORE;
1029              break;
1030    
1031            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1032    
1033            default:            default:
# Line 999  for (;;) Line 1182  for (;;)
1182            break;            break;
1183    
1184            case PT_LAMP:            case PT_LAMP:
1185            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1186                prop->chartype == ucp_Lt;
1187            break;            break;
1188    
1189            case PT_GC:            case PT_GC:
# Line 1014  for (;;) Line 1198  for (;;)
1198            OK = prop->script == code[3];            OK = prop->script == code[3];
1199            break;            break;
1200    
1201              /* These are specials for combination cases. */
1202    
1203              case PT_ALNUM:
1204              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1205                   _pcre_ucp_gentype[prop->chartype] == ucp_N;
1206              break;
1207    
1208              case PT_SPACE:    /* Perl space */
1209              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1210                   c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1211              break;
1212    
1213              case PT_PXSPACE:  /* POSIX space */
1214              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1215                   c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1216                   c == CHAR_FF || c == CHAR_CR;
1217              break;
1218    
1219              case PT_WORD:
1220              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1221                   _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1222                   c == CHAR_UNDERSCORE;
1223              break;
1224    
1225            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1226    
1227            default:            default:
# Line 1221  for (;;) Line 1429  for (;;)
1429            break;            break;
1430    
1431            case PT_LAMP:            case PT_LAMP:
1432            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1433                prop->chartype == ucp_Lt;
1434            break;            break;
1435    
1436            case PT_GC:            case PT_GC:
# Line 1236  for (;;) Line 1445  for (;;)
1445            OK = prop->script == code[3];            OK = prop->script == code[3];
1446            break;            break;
1447    
1448              /* These are specials for combination cases. */
1449    
1450              case PT_ALNUM:
1451              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1452                   _pcre_ucp_gentype[prop->chartype] == ucp_N;
1453              break;
1454    
1455              case PT_SPACE:    /* Perl space */
1456              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1457                   c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1458              break;
1459    
1460              case PT_PXSPACE:  /* POSIX space */
1461              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1462                   c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1463                   c == CHAR_FF || c == CHAR_CR;
1464              break;
1465    
1466              case PT_WORD:
1467              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1468                   _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1469                   c == CHAR_UNDERSCORE;
1470              break;
1471    
1472            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1473    
1474            default:            default:
# Line 1468  for (;;) Line 1701  for (;;)
1701            break;            break;
1702    
1703            case PT_LAMP:            case PT_LAMP:
1704            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
1705                prop->chartype == ucp_Lt;
1706            break;            break;
1707    
1708            case PT_GC:            case PT_GC:
# Line 1483  for (;;) Line 1717  for (;;)
1717            OK = prop->script == code[5];            OK = prop->script == code[5];
1718            break;            break;
1719    
1720              /* These are specials for combination cases. */
1721    
1722              case PT_ALNUM:
1723              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1724                   _pcre_ucp_gentype[prop->chartype] == ucp_N;
1725              break;
1726    
1727              case PT_SPACE:    /* Perl space */
1728              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1729                   c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
1730              break;
1731    
1732              case PT_PXSPACE:  /* POSIX space */
1733              OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
1734                   c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
1735                   c == CHAR_FF || c == CHAR_CR;
1736              break;
1737    
1738              case PT_WORD:
1739              OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
1740                   _pcre_ucp_gentype[prop->chartype] == ucp_N ||
1741                   c == CHAR_UNDERSCORE;
1742              break;
1743    
1744            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
1745    
1746            default:            default:
# Line 2110  for (;;) Line 2368  for (;;)
2368          points to the byte after the end of the class. If there is a          points to the byte after the end of the class. If there is a
2369          quantifier, this is where it will be. */          quantifier, this is where it will be. */
2370    
2371          next_state_offset = ecode - start_code;          next_state_offset = (int)(ecode - start_code);
2372    
2373          switch (*ecode)          switch (*ecode)
2374            {            {
# Line 2162  for (;;) Line 2420  for (;;)
2420        though the other "backtracking verbs" are not supported. */        though the other "backtracking verbs" are not supported. */
2421    
2422        case OP_FAIL:        case OP_FAIL:
2423          forced_fail++;    /* Count FAILs for multiple states */
2424        break;        break;
2425    
2426        case OP_ASSERT:        case OP_ASSERT:
# Line 2180  for (;;) Line 2439  for (;;)
2439            md,                                   /* static match data */            md,                                   /* static match data */
2440            code,                                 /* this subexpression's code */            code,                                 /* this subexpression's code */
2441            ptr,                                  /* where we currently are */            ptr,                                  /* where we currently are */
2442            ptr - start_subject,                  /* start offset */            (int)(ptr - start_subject),           /* start offset */
2443            local_offsets,                        /* offset vector */            local_offsets,                        /* offset vector */
2444            sizeof(local_offsets)/sizeof(int),    /* size of same */            sizeof(local_offsets)/sizeof(int),    /* size of same */
2445            local_workspace,                      /* workspace vector */            local_workspace,                      /* workspace vector */
# Line 2189  for (;;) Line 2448  for (;;)
2448            rlevel,                               /* function recursion level */            rlevel,                               /* function recursion level */
2449            recursing);                           /* pass on regex recursion */            recursing);                           /* pass on regex recursion */
2450    
2451            if (rc == PCRE_ERROR_DFA_UITEM) return rc;
2452          if ((rc >= 0) == (codevalue == OP_ASSERT || codevalue == OP_ASSERTBACK))          if ((rc >= 0) == (codevalue == OP_ASSERT || codevalue == OP_ASSERTBACK))
2453              { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }              { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); }
2454          }          }
2455        break;        break;
2456    
# Line 2217  for (;;) Line 2477  for (;;)
2477              cb.callout_number   = code[LINK_SIZE+2];              cb.callout_number   = code[LINK_SIZE+2];
2478              cb.offset_vector    = offsets;              cb.offset_vector    = offsets;
2479              cb.subject          = (PCRE_SPTR)start_subject;              cb.subject          = (PCRE_SPTR)start_subject;
2480              cb.subject_length   = end_subject - start_subject;              cb.subject_length   = (int)(end_subject - start_subject);
2481              cb.start_match      = current_subject - start_subject;              cb.start_match      = (int)(current_subject - start_subject);
2482              cb.current_position = ptr - start_subject;              cb.current_position = (int)(ptr - start_subject);
2483              cb.pattern_position = GET(code, LINK_SIZE + 3);              cb.pattern_position = GET(code, LINK_SIZE + 3);
2484              cb.next_item_length = GET(code, 3 + 2*LINK_SIZE);              cb.next_item_length = GET(code, 3 + 2*LINK_SIZE);
2485              cb.capture_top      = 1;              cb.capture_top      = 1;
# Line 2235  for (;;) Line 2495  for (;;)
2495    
2496          /* Back reference conditions are not supported */          /* Back reference conditions are not supported */
2497    
2498          if (condcode == OP_CREF) return PCRE_ERROR_DFA_UCOND;          if (condcode == OP_CREF || condcode == OP_NCREF)
2499              return PCRE_ERROR_DFA_UCOND;
2500    
2501          /* The DEFINE condition is always false */          /* The DEFINE condition is always false */
2502    
# Line 2246  for (;;) Line 2507  for (;;)
2507          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
2508          recursed groups. */          recursed groups. */
2509    
2510          else if (condcode == OP_RREF)          else if (condcode == OP_RREF || condcode == OP_NRREF)
2511            {            {
2512            int value = GET2(code, LINK_SIZE+2);            int value = GET2(code, LINK_SIZE+2);
2513            if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;            if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;
# Line 2269  for (;;) Line 2530  for (;;)
2530              md,                                   /* fixed match data */              md,                                   /* fixed match data */
2531              asscode,                              /* this subexpression's code */              asscode,                              /* this subexpression's code */
2532              ptr,                                  /* where we currently are */              ptr,                                  /* where we currently are */
2533              ptr - start_subject,                  /* start offset */              (int)(ptr - start_subject),           /* start offset */
2534              local_offsets,                        /* offset vector */              local_offsets,                        /* offset vector */
2535              sizeof(local_offsets)/sizeof(int),    /* size of same */              sizeof(local_offsets)/sizeof(int),    /* size of same */
2536              local_workspace,                      /* workspace vector */              local_workspace,                      /* workspace vector */
# Line 2278  for (;;) Line 2539  for (;;)
2539              rlevel,                               /* function recursion level */              rlevel,                               /* function recursion level */
2540              recursing);                           /* pass on regex recursion */              recursing);                           /* pass on regex recursion */
2541    
2542              if (rc == PCRE_ERROR_DFA_UITEM) return rc;
2543            if ((rc >= 0) ==            if ((rc >= 0) ==
2544                  (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))                  (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))
2545              { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }              { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); }
2546            else            else
2547              { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }              { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
2548            }            }
# Line 2301  for (;;) Line 2563  for (;;)
2563            md,                                   /* fixed match data */            md,                                   /* fixed match data */
2564            start_code + GET(code, 1),            /* this subexpression's code */            start_code + GET(code, 1),            /* this subexpression's code */
2565            ptr,                                  /* where we currently are */            ptr,                                  /* where we currently are */
2566            ptr - start_subject,                  /* start offset */            (int)(ptr - start_subject),           /* start offset */
2567            local_offsets,                        /* offset vector */            local_offsets,                        /* offset vector */
2568            sizeof(local_offsets)/sizeof(int),    /* size of same */            sizeof(local_offsets)/sizeof(int),    /* size of same */
2569            local_workspace,                      /* workspace vector */            local_workspace,                      /* workspace vector */
# Line 2353  for (;;) Line 2615  for (;;)
2615            md,                                   /* fixed match data */            md,                                   /* fixed match data */
2616            code,                                 /* this subexpression's code */            code,                                 /* this subexpression's code */
2617            ptr,                                  /* where we currently are */            ptr,                                  /* where we currently are */
2618            ptr - start_subject,                  /* start offset */            (int)(ptr - start_subject),           /* start offset */
2619            local_offsets,                        /* offset vector */            local_offsets,                        /* offset vector */
2620            sizeof(local_offsets)/sizeof(int),    /* size of same */            sizeof(local_offsets)/sizeof(int),    /* size of same */
2621            local_workspace,                      /* workspace vector */            local_workspace,                      /* workspace vector */
# Line 2370  for (;;) Line 2632  for (;;)
2632    
2633            do { end_subpattern += GET(end_subpattern, 1); }            do { end_subpattern += GET(end_subpattern, 1); }
2634              while (*end_subpattern == OP_ALT);              while (*end_subpattern == OP_ALT);
2635            next_state_offset = end_subpattern - start_code + LINK_SIZE + 1;            next_state_offset =
2636                (int)(end_subpattern - start_code + LINK_SIZE + 1);
2637    
2638            /* If the end of this subpattern is KETRMAX or KETRMIN, we must            /* If the end of this subpattern is KETRMAX or KETRMIN, we must
2639            arrange for the repeat state also to be added to the relevant list.            arrange for the repeat state also to be added to the relevant list.
# Line 2378  for (;;) Line 2641  for (;;)
2641    
2642            repeat_state_offset = (*end_subpattern == OP_KETRMAX ||            repeat_state_offset = (*end_subpattern == OP_KETRMAX ||
2643                                   *end_subpattern == OP_KETRMIN)?                                   *end_subpattern == OP_KETRMIN)?
2644              end_subpattern - start_code - GET(end_subpattern, 1) : -1;              (int)(end_subpattern - start_code - GET(end_subpattern, 1)) : -1;
2645    
2646            /* If we have matched an empty string, add the next state at the            /* If we have matched an empty string, add the next state at the
2647            current character pointer. This is important so that the duplicate            current character pointer. This is important so that the duplicate
# Line 2442  for (;;) Line 2705  for (;;)
2705          cb.callout_number   = code[1];          cb.callout_number   = code[1];
2706          cb.offset_vector    = offsets;          cb.offset_vector    = offsets;
2707          cb.subject          = (PCRE_SPTR)start_subject;          cb.subject          = (PCRE_SPTR)start_subject;
2708          cb.subject_length   = end_subject - start_subject;          cb.subject_length   = (int)(end_subject - start_subject);
2709          cb.start_match      = current_subject - start_subject;          cb.start_match      = (int)(current_subject - start_subject);
2710          cb.current_position = ptr - start_subject;          cb.current_position = (int)(ptr - start_subject);
2711          cb.pattern_position = GET(code, 2);          cb.pattern_position = GET(code, 2);
2712          cb.next_item_length = GET(code, 2 + LINK_SIZE);          cb.next_item_length = GET(code, 2 + LINK_SIZE);
2713          cb.capture_top      = 1;          cb.capture_top      = 1;
# Line 2469  for (;;) Line 2732  for (;;)
2732    /* We have finished the processing at the current subject character. If no    /* We have finished the processing at the current subject character. If no
2733    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
2734    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
2735    matching has been requested, check for appropriate conditions. */    matching has been requested, check for appropriate conditions.
2736    
2737      The "forced_ fail" variable counts the number of (*F) encountered for the
2738      character. If it is equal to the original active_count (saved in
2739      workspace[1]) it means that (*F) was found on every active state. In this
2740      case we don't want to give a partial match.
2741    
2742      The "could_continue" variable is true if a state could have continued but
2743      for the fact that the end of the subject was reached. */
2744    
2745    if (new_count <= 0)    if (new_count <= 0)
2746      {      {
2747      if (match_count < 0 &&                     /* No matches found */      if (rlevel == 1 &&                               /* Top level, and */
2748          rlevel == 1 &&                         /* Top level match function */          could_continue &&                            /* Some could go on */
2749          (md->moptions & PCRE_PARTIAL) != 0 &&  /* Want partial matching */          forced_fail != workspace[1] &&               /* Not all forced fail & */
2750            (                                            /* either... */
2751            (md->moptions & PCRE_PARTIAL_HARD) != 0      /* Hard partial */
2752            ||                                           /* or... */
2753            ((md->moptions & PCRE_PARTIAL_SOFT) != 0 &&  /* Soft partial and */
2754             match_count < 0)                            /* no matches */
2755            ) &&                                         /* And... */
2756          ptr >= end_subject &&                  /* Reached end of subject */          ptr >= end_subject &&                  /* Reached end of subject */
2757          ptr > current_subject)                 /* Matched non-empty string */          ptr > md->start_used_ptr)              /* Inspected non-empty string */
2758        {        {
2759        if (offsetcount >= 2)        if (offsetcount >= 2)
2760          {          {
2761          offsets[0] = current_subject - start_subject;          offsets[0] = (int)(md->start_used_ptr - start_subject);
2762          offsets[1] = end_subject - start_subject;          offsets[1] = (int)(end_subject - start_subject);
2763          }          }
2764        match_count = PCRE_ERROR_PARTIAL;        match_count = PCRE_ERROR_PARTIAL;
2765        }        }
# Line 2623  md->start_code = (const uschar *)argumen Line 2900  md->start_code = (const uschar *)argumen
2900      re->name_table_offset + re->name_count * re->name_entry_size;      re->name_table_offset + re->name_count * re->name_entry_size;
2901  md->start_subject = (const unsigned char *)subject;  md->start_subject = (const unsigned char *)subject;
2902  md->end_subject = end_subject;  md->end_subject = end_subject;
2903    md->start_offset = start_offset;
2904  md->moptions = options;  md->moptions = options;
2905  md->poptions = re->options;  md->poptions = re->options;
2906    
# Line 2727  if (!anchored) Line 3005  if (!anchored)
3005      }      }
3006    else    else
3007      {      {
3008      if (startline && study != NULL &&      if (!startline && study != NULL &&
3009           (study->options & PCRE_STUDY_MAPPED) != 0)           (study->flags & PCRE_STUDY_MAPPED) != 0)
3010        start_bits = study->start_bits;        start_bits = study->start_bits;
3011      }      }
3012    }    }
# Line 2779  for (;;) Line 3057  for (;;)
3057        }        }
3058    
3059      /* There are some optimizations that avoid running the match if a known      /* There are some optimizations that avoid running the match if a known
3060      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
3061      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. */  
3062    
3063      if ((options & PCRE_NO_START_OPTIMIZE) == 0)      if ((options & PCRE_NO_START_OPTIMIZE) == 0)
3064        {        {
   
3065        /* Advance to a known first byte. */        /* Advance to a known first byte. */
3066    
3067        if (first_byte >= 0)        if (first_byte >= 0)
# Line 2842  for (;;) Line 3118  for (;;)
3118          while (current_subject < end_subject)          while (current_subject < end_subject)
3119            {            {
3120            register unsigned int c = *current_subject;            register unsigned int c = *current_subject;
3121            if ((start_bits[c/8] & (1 << (c&7))) == 0) current_subject++;            if ((start_bits[c/8] & (1 << (c&7))) == 0)
3122              else break;              {
3123                current_subject++;
3124    #ifdef SUPPORT_UTF8
3125                if (utf8)
3126                  while(current_subject < end_subject &&
3127                        (*current_subject & 0xc0) == 0x80) current_subject++;
3128    #endif
3129                }
3130              else break;
3131            }            }
3132          }          }
3133        }        }
# Line 2851  for (;;) Line 3135  for (;;)
3135      /* Restore fudged end_subject */      /* Restore fudged end_subject */
3136    
3137      end_subject = save_end_subject;      end_subject = save_end_subject;
     }  
3138    
3139    /* 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
3140    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
3141    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  
   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, and can  
   also be explicitly deactivated. */  
   
   if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&  
       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);  
   
     /* We don't need to repeat the search if we haven't yet reached the  
     place we found it at last time. */  
3142    
3143      if (p > req_byte_ptr)      if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&
3144            (options & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) == 0)
3145        {        {
3146        if (req_byte_caseless)        /* If the pattern was studied, a minimum subject length may be set. This
3147          {        is a lower bound; no actual string of that length may actually match the
3148          while (p < end_subject)        pattern. Although the value is, strictly, in characters, we treat it as
3149            {        bytes to avoid spending too much time in this optimization. */
3150            register int pp = *p++;  
3151            if (pp == req_byte || pp == req_byte2) { p--; break; }        if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
3152            }            (pcre_uint32)(end_subject - current_subject) < study->minlength)
3153          }          return PCRE_ERROR_NOMATCH;
3154        else  
3155          /* If req_byte is set, we know that that character must appear in the
3156          subject for the match to succeed. If the first character is set, req_byte
3157          must be later in the subject; otherwise the test starts at the match
3158          point. This optimization can save a huge amount of work in patterns with
3159          nested unlimited repeats that aren't going to match. Writing separate
3160          code for cased/caseless versions makes it go faster, as does using an
3161          autoincrement and backing off on a match.
3162    
3163          HOWEVER: when the subject string is very, very long, searching to its end
3164          can take a long time, and give bad performance on quite ordinary
3165          patterns. This showed up when somebody was matching /^C/ on a 32-megabyte
3166          string... so we don't do this when the string is sufficiently long. */
3167    
3168          if (req_byte >= 0 && end_subject - current_subject < REQ_BYTE_MAX)
3169          {          {
3170          while (p < end_subject)          register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);
3171    
3172            /* We don't need to repeat the search if we haven't yet reached the
3173            place we found it at last time. */
3174    
3175            if (p > req_byte_ptr)
3176            {            {
3177            if (*p++ == req_byte) { p--; break; }            if (req_byte_caseless)
3178            }              {
3179          }              while (p < end_subject)
3180                  {
3181                  register int pp = *p++;
3182                  if (pp == req_byte || pp == req_byte2) { p--; break; }
3183                  }
3184                }
3185              else
3186                {
3187                while (p < end_subject)
3188                  {
3189                  if (*p++ == req_byte) { p--; break; }
3190                  }
3191                }
3192    
3193        /* If we can't find the required character, break the matching loop,            /* If we can't find the required character, break the matching loop,
3194        which will cause a return or PCRE_ERROR_NOMATCH. */            which will cause a return or PCRE_ERROR_NOMATCH. */
3195    
3196        if (p >= end_subject) break;            if (p >= end_subject) break;
3197    
3198        /* If we have found the required character, save the point where we            /* If we have found the required character, save the point where we
3199        found it, so that we don't search again next time round the loop if            found it, so that we don't search again next time round the loop if
3200        the start hasn't passed this character yet. */            the start hasn't passed this character yet. */
3201    
3202        req_byte_ptr = p;            req_byte_ptr = p;
3203              }
3204            }
3205        }        }
3206      }      }   /* End of optimizations that are done when not restarting */
3207    
3208    /* OK, now we can do the business */    /* OK, now we can do the business */
3209    
3210      md->start_used_ptr = current_subject;
3211    
3212    rc = internal_dfa_exec(    rc = internal_dfa_exec(
3213      md,                                /* fixed match data */      md,                                /* fixed match data */
3214      md->start_code,                    /* this subexpression's code */      md->start_code,                    /* this subexpression's code */

Legend:
Removed from v.426  
changed lines
  Added in v.553

  ViewVC Help
Powered by ViewVC 1.1.5