/[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 93 by nigel, Sat Feb 24 21:41:42 2007 UTC revision 442 by ph10, Fri Sep 11 10:21:02 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-2006 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
77    #include "config.h"
78    #endif
79    
80  #define NLBLOCK md             /* Block containing newline information */  #define NLBLOCK md             /* Block containing newline information */
81  #define PSSTART start_subject  /* Field containing processed string start */  #define PSSTART start_subject  /* Field containing processed string start */
82  #define PSEND   end_subject    /* Field containing processed string end */  #define PSEND   end_subject    /* Field containing processed string end */
# Line 56  applications. */ Line 89  applications. */
89  #define SP "                   "  #define SP "                   "
90    
91    
   
92  /*************************************************  /*************************************************
93  *      Code parameters and static tables         *  *      Code parameters and static tables         *
94  *************************************************/  *************************************************/
95    
96  /* These are offsets that are used to turn the OP_TYPESTAR and friends opcodes  /* These are offsets that are used to turn the OP_TYPESTAR and friends opcodes
97  into others, under special conditions. A gap of 20 between the blocks should be  into others, under special conditions. A gap of 20 between the blocks should be
98  enough. */  enough. The resulting opcodes don't have to be less than 256 because they are
99    never stored, so we push them well clear of the normal opcodes. */
100    
101  #define OP_PROP_EXTRA 100  #define OP_PROP_EXTRA       300
102  #define OP_EXTUNI_EXTRA 120  #define OP_EXTUNI_EXTRA     320
103  #define OP_ANYNL_EXTRA 140  #define OP_ANYNL_EXTRA      340
104    #define OP_HSPACE_EXTRA     360
105    #define OP_VSPACE_EXTRA     380
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 is 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. */  small value. ***NOTE*** If the start of this table is modified, the two tables
113    that follow must also be modified. */
114    
115  static uschar coptable[] = {  static const uschar coptable[] = {
116    0,                             /* End                                    */    0,                             /* End                                    */
117    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  /* \A, \G, \B, \b, \D, \d, \S, \s, \W, \w */    0, 0, 0, 0, 0,                 /* \A, \G, \K, \B, \b                     */
118    0, 0,                          /* Any, Anybyte                           */    0, 0, 0, 0, 0, 0,              /* \D, \d, \S, \s, \W, \w                 */
119    0, 0, 0, 0,                    /* NOTPROP, PROP, EXTUNI, ANYNL           */    0, 0, 0,                       /* Any, AllAny, Anybyte                   */
120      0, 0, 0,                       /* NOTPROP, PROP, EXTUNI                  */
121      0, 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */
122    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */    0, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */
123    1,                             /* Char                                   */    1,                             /* Char                                   */
124    1,                             /* Charnc                                 */    1,                             /* Charnc                                 */
# Line 120  static uschar coptable[] = { Line 158  static uschar coptable[] = {
158    0,                             /* CREF                                   */    0,                             /* CREF                                   */
159    0,                             /* RREF                                   */    0,                             /* RREF                                   */
160    0,                             /* DEF                                    */    0,                             /* DEF                                    */
161    0, 0                           /* BRAZERO, BRAMINZERO                    */    0, 0,                          /* BRAZERO, BRAMINZERO                    */
162      0, 0, 0, 0,                    /* PRUNE, SKIP, THEN, COMMIT              */
163      0, 0, 0                        /* FAIL, ACCEPT, SKIPZERO                 */
164  };  };
165    
166  /* 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,
167  and \w */  and \w */
168    
169  static uschar toptable1[] = {  static const uschar toptable1[] = {
170    0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 0,
171    ctype_digit, ctype_digit,    ctype_digit, ctype_digit,
172    ctype_space, ctype_space,    ctype_space, ctype_space,
173    ctype_word,  ctype_word,    ctype_word,  ctype_word,
174    0                               /* OP_ANY */    0, 0                            /* OP_ANY, OP_ALLANY */
175  };  };
176    
177  static uschar toptable2[] = {  static const uschar toptable2[] = {
178    0, 0, 0, 0, 0,    0, 0, 0, 0, 0, 0,
179    ctype_digit, 0,    ctype_digit, 0,
180    ctype_space, 0,    ctype_space, 0,
181    ctype_word,  0,    ctype_word,  0,
182    1                               /* OP_ANY */    1, 1                            /* OP_ANY, OP_ALLANY */
183  };  };
184    
185    
# Line 211  Arguments: Line 251  Arguments:
251    rlevel            function call recursion level    rlevel            function call recursion level
252    recursing         regex recursive call level    recursing         regex recursive call level
253    
254  Returns:            > 0 =>  Returns:            > 0 => number of match offset pairs placed in offsets
255                      = 0 =>                      = 0 => offsets overflowed; longest matches are present
256                       -1 => failed to match                       -1 => failed to match
257                     < -1 => some kind of unexpected problem                     < -1 => some kind of unexpected problem
258    
# Line 377  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 442  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 499  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;
     int chartype, script;  
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 532  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 555  for (;;) Line 603  for (;;)
603      permitted.      permitted.
604    
605      We also use this mechanism for opcodes such as OP_TYPEPLUS that take an      We also use this mechanism for opcodes such as OP_TYPEPLUS that take an
606      argument that is not a data character - but is always one byte long.      argument that is not a data character - but is always one byte long. We
607      Unfortunately, we have to take special action to deal with  \P, \p, and      have to take special action to deal with  \P, \p, \H, \h, \V, \v and \X in
608      \X in this case. To keep the other cases fast, convert these ones to new      this case. To keep the other cases fast, convert these ones to new opcodes.
609      opcodes. */      */
610    
611      if (coptable[codevalue] > 0)      if (coptable[codevalue] > 0)
612        {        {
# Line 576  for (;;) Line 624  for (;;)
624            case OP_PROP: codevalue += OP_PROP_EXTRA; break;            case OP_PROP: codevalue += OP_PROP_EXTRA; break;
625            case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break;            case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break;
626            case OP_EXTUNI: codevalue += OP_EXTUNI_EXTRA; break;            case OP_EXTUNI: codevalue += OP_EXTUNI_EXTRA; break;
627              case OP_NOT_HSPACE:
628              case OP_HSPACE: codevalue += OP_HSPACE_EXTRA; break;
629              case OP_NOT_VSPACE:
630              case OP_VSPACE: codevalue += OP_VSPACE_EXTRA; break;
631            default: break;            default: break;
632            }            }
633          }          }
# Line 595  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 609  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 676  for (;;) Line 736  for (;;)
736        break;        break;
737    
738        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
739          case OP_SKIPZERO:
740          code += 1 + GET(code, 2);
741          while (*code == OP_ALT) code += GET(code, 1);
742          ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);
743          break;
744    
745          /*-----------------------------------------------------------------*/
746        case OP_CIRC:        case OP_CIRC:
747        if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||        if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||
748            ((ims & PCRE_MULTILINE) != 0 &&            ((ims & PCRE_MULTILINE) != 0 &&
# Line 714  for (;;) Line 781  for (;;)
781    
782        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
783        case OP_ANY:        case OP_ANY:
784        if (clen > 0 && ((ims & PCRE_DOTALL) != 0 || !IS_NEWLINE(ptr)))        if (clen > 0 && !IS_NEWLINE(ptr))
785            { ADD_NEW(state_offset + 1, 0); }
786          break;
787    
788          /*-----------------------------------------------------------------*/
789          case OP_ALLANY:
790          if (clen > 0)
791          { ADD_NEW(state_offset + 1, 0); }          { ADD_NEW(state_offset + 1, 0); }
792        break;        break;
793    
# Line 729  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 766  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 774  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 783  for (;;) Line 862  for (;;)
862        break;        break;
863    
864    
 #ifdef SUPPORT_UCP  
   
865        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
866        /* Check the next character by Unicode property. We will get here only        /* Check the next character by Unicode property. We will get here only
867        if the support is in the binary; otherwise a compile-time error occurs.        if the support is in the binary; otherwise a compile-time error occurs.
868        */        */
869    
870    #ifdef SUPPORT_UCP
871        case OP_PROP:        case OP_PROP:
872        case OP_NOTPROP:        case OP_NOTPROP:
873        if (clen > 0)        if (clen > 0)
874          {          {
875          BOOL OK;          BOOL OK;
876          int category = _pcre_ucp_findprop(c, &chartype, &script);          const ucd_record * prop = GET_UCD(c);
877          switch(code[1])          switch(code[1])
878            {            {
879            case PT_ANY:            case PT_ANY:
# Line 803  for (;;) Line 881  for (;;)
881            break;            break;
882    
883            case PT_LAMP:            case PT_LAMP:
884            OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt;
885            break;            break;
886    
887            case PT_GC:            case PT_GC:
888            OK = category == code[2];            OK = _pcre_ucp_gentype[prop->chartype] == code[2];
889            break;            break;
890    
891            case PT_PC:            case PT_PC:
892            OK = chartype == code[2];            OK = prop->chartype == code[2];
893            break;            break;
894    
895            case PT_SC:            case PT_SC:
896            OK = script == code[2];            OK = prop->script == code[2];
897            break;            break;
898    
899            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
# Line 835  for (;;) Line 913  for (;;)
913  /* ========================================================================== */  /* ========================================================================== */
914        /* These opcodes likewise inspect the subject character, but have an        /* These opcodes likewise inspect the subject character, but have an
915        argument that is not a data character. It is one of these opcodes:        argument that is not a data character. It is one of these opcodes:
916        OP_ANY, OP_DIGIT, OP_NOT_DIGIT, OP_WHITESPACE, OP_NOT_SPACE, OP_WORDCHAR,        OP_ANY, OP_ALLANY, OP_DIGIT, OP_NOT_DIGIT, OP_WHITESPACE, OP_NOT_SPACE,
917        OP_NOT_WORDCHAR. The value is loaded into d. */        OP_WORDCHAR, OP_NOT_WORDCHAR. The value is loaded into d. */
918    
919        case OP_TYPEPLUS:        case OP_TYPEPLUS:
920        case OP_TYPEMINPLUS:        case OP_TYPEMINPLUS:
# Line 847  for (;;) Line 925  for (;;)
925          {          {
926          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
927              (c < 256 &&              (c < 256 &&
928                (d != OP_ANY ||                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
                (ims & PCRE_DOTALL) != 0 ||  
                !IS_NEWLINE(ptr)  
               ) &&  
929                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
930            {            {
931            if (count > 0 && codevalue == OP_TYPEPOSPLUS)            if (count > 0 && codevalue == OP_TYPEPOSPLUS)
# Line 873  for (;;) Line 948  for (;;)
948          {          {
949          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
950              (c < 256 &&              (c < 256 &&
951                (d != OP_ANY ||                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
                (ims & PCRE_DOTALL) != 0 ||  
                !IS_NEWLINE(ptr)  
               ) &&  
952                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
953            {            {
954            if (codevalue == OP_TYPEPOSQUERY)            if (codevalue == OP_TYPEPOSQUERY)
# Line 898  for (;;) Line 970  for (;;)
970          {          {
971          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
972              (c < 256 &&              (c < 256 &&
973                (d != OP_ANY ||                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
                (ims & PCRE_DOTALL) != 0 ||  
                !IS_NEWLINE(ptr)  
               ) &&  
974                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
975            {            {
976            if (codevalue == OP_TYPEPOSSTAR)            if (codevalue == OP_TYPEPOSSTAR)
# Line 921  for (;;) Line 990  for (;;)
990          {          {
991          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
992              (c < 256 &&              (c < 256 &&
993                (d != OP_ANY ||                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
                (ims & PCRE_DOTALL) != 0 ||  
                !IS_NEWLINE(ptr)  
               ) &&  
994                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
995            {            {
996            if (++count >= GET2(code, 1))            if (++count >= GET2(code, 1))
# Line 945  for (;;) Line 1011  for (;;)
1011          {          {
1012          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
1013              (c < 256 &&              (c < 256 &&
1014                (d != OP_ANY ||                (d != OP_ANY || !IS_NEWLINE(ptr)) &&
                (ims & PCRE_DOTALL) != 0 ||  
                !IS_NEWLINE(ptr)  
               ) &&  
1015                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
1016            {            {
1017            if (codevalue == OP_TYPEPOSUPTO)            if (codevalue == OP_TYPEPOSUPTO)
# Line 970  for (;;) Line 1033  for (;;)
1033        argument. It keeps the code above fast for the other cases. The argument        argument. It keeps the code above fast for the other cases. The argument
1034        is in the d variable. */        is in the d variable. */
1035    
1036    #ifdef SUPPORT_UCP
1037        case OP_PROP_EXTRA + OP_TYPEPLUS:        case OP_PROP_EXTRA + OP_TYPEPLUS:
1038        case OP_PROP_EXTRA + OP_TYPEMINPLUS:        case OP_PROP_EXTRA + OP_TYPEMINPLUS:
1039        case OP_PROP_EXTRA + OP_TYPEPOSPLUS:        case OP_PROP_EXTRA + OP_TYPEPOSPLUS:
# Line 978  for (;;) Line 1042  for (;;)
1042        if (clen > 0)        if (clen > 0)
1043          {          {
1044          BOOL OK;          BOOL OK;
1045          int category = _pcre_ucp_findprop(c, &chartype, &script);          const ucd_record * prop = GET_UCD(c);
1046          switch(code[2])          switch(code[2])
1047            {            {
1048            case PT_ANY:            case PT_ANY:
# Line 986  for (;;) Line 1050  for (;;)
1050            break;            break;
1051    
1052            case PT_LAMP:            case PT_LAMP:
1053            OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt;
1054            break;            break;
1055    
1056            case PT_GC:            case PT_GC:
1057            OK = category == code[3];            OK = _pcre_ucp_gentype[prop->chartype] == code[3];
1058            break;            break;
1059    
1060            case PT_PC:            case PT_PC:
1061            OK = chartype == code[3];            OK = prop->chartype == code[3];
1062            break;            break;
1063    
1064            case PT_SC:            case PT_SC:
1065            OK = script == code[3];            OK = prop->script == code[3];
1066            break;            break;
1067    
1068            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
# Line 1027  for (;;) Line 1091  for (;;)
1091        case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS:        case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS:
1092        count = current_state->count;  /* Already matched */        count = current_state->count;  /* Already matched */
1093        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1094        if (clen > 0 && _pcre_ucp_findprop(c, &chartype, &script) != ucp_M)        if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
1095          {          {
1096          const uschar *nptr = ptr + clen;          const uschar *nptr = ptr + clen;
1097          int ncount = 0;          int ncount = 0;
# Line 1041  for (;;) Line 1105  for (;;)
1105            int nd;            int nd;
1106            int ndlen = 1;            int ndlen = 1;
1107            GETCHARLEN(nd, nptr, ndlen);            GETCHARLEN(nd, nptr, ndlen);
1108            if (_pcre_ucp_findprop(nd, &chartype, &script) != ucp_M) break;            if (UCD_CATEGORY(nd) != ucp_M) break;
1109            ncount++;            ncount++;
1110            nptr += ndlen;            nptr += ndlen;
1111            }            }
# Line 1049  for (;;) Line 1113  for (;;)
1113          ADD_NEW_DATA(-state_offset, count, ncount);          ADD_NEW_DATA(-state_offset, count, ncount);
1114          }          }
1115        break;        break;
1116    #endif
1117    
1118        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1119        case OP_ANYNL_EXTRA + OP_TYPEPLUS:        case OP_ANYNL_EXTRA + OP_TYPEPLUS:
# Line 1061  for (;;) Line 1126  for (;;)
1126          int ncount = 0;          int ncount = 0;
1127          switch (c)          switch (c)
1128            {            {
1129              case 0x000b:
1130              case 0x000c:
1131              case 0x0085:
1132              case 0x2028:
1133              case 0x2029:
1134              if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1135              goto ANYNL01;
1136    
1137            case 0x000d:            case 0x000d:
1138            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1139            /* Fall through */            /* Fall through */
1140    
1141              ANYNL01:
1142              case 0x000a:
1143              if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)
1144                {
1145                active_count--;           /* Remove non-match possibility */
1146                next_active_state--;
1147                }
1148              count++;
1149              ADD_NEW_DATA(-state_offset, count, ncount);
1150              break;
1151    
1152              default:
1153              break;
1154              }
1155            }
1156          break;
1157    
1158          /*-----------------------------------------------------------------*/
1159          case OP_VSPACE_EXTRA + OP_TYPEPLUS:
1160          case OP_VSPACE_EXTRA + OP_TYPEMINPLUS:
1161          case OP_VSPACE_EXTRA + OP_TYPEPOSPLUS:
1162          count = current_state->count;  /* Already matched */
1163          if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1164          if (clen > 0)
1165            {
1166            BOOL OK;
1167            switch (c)
1168              {
1169            case 0x000a:            case 0x000a:
1170            case 0x000b:            case 0x000b:
1171            case 0x000c:            case 0x000c:
1172              case 0x000d:
1173            case 0x0085:            case 0x0085:
1174            case 0x2028:            case 0x2028:
1175            case 0x2029:            case 0x2029:
1176            if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)            OK = TRUE;
1177              break;
1178    
1179              default:
1180              OK = FALSE;
1181              break;
1182              }
1183    
1184            if (OK == (d == OP_VSPACE))
1185              {
1186              if (count > 0 && codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSPLUS)
1187              {              {
1188              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1189              next_active_state--;              next_active_state--;
1190              }              }
1191            count++;            count++;
1192            ADD_NEW_DATA(-state_offset, count, ncount);            ADD_NEW_DATA(-state_offset, count, 0);
1193              }
1194            }
1195          break;
1196    
1197          /*-----------------------------------------------------------------*/
1198          case OP_HSPACE_EXTRA + OP_TYPEPLUS:
1199          case OP_HSPACE_EXTRA + OP_TYPEMINPLUS:
1200          case OP_HSPACE_EXTRA + OP_TYPEPOSPLUS:
1201          count = current_state->count;  /* Already matched */
1202          if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1203          if (clen > 0)
1204            {
1205            BOOL OK;
1206            switch (c)
1207              {
1208              case 0x09:      /* HT */
1209              case 0x20:      /* SPACE */
1210              case 0xa0:      /* NBSP */
1211              case 0x1680:    /* OGHAM SPACE MARK */
1212              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1213              case 0x2000:    /* EN QUAD */
1214              case 0x2001:    /* EM QUAD */
1215              case 0x2002:    /* EN SPACE */
1216              case 0x2003:    /* EM SPACE */
1217              case 0x2004:    /* THREE-PER-EM SPACE */
1218              case 0x2005:    /* FOUR-PER-EM SPACE */
1219              case 0x2006:    /* SIX-PER-EM SPACE */
1220              case 0x2007:    /* FIGURE SPACE */
1221              case 0x2008:    /* PUNCTUATION SPACE */
1222              case 0x2009:    /* THIN SPACE */
1223              case 0x200A:    /* HAIR SPACE */
1224              case 0x202f:    /* NARROW NO-BREAK SPACE */
1225              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1226              case 0x3000:    /* IDEOGRAPHIC SPACE */
1227              OK = TRUE;
1228            break;            break;
1229    
1230            default:            default:
1231              OK = FALSE;
1232            break;            break;
1233            }            }
1234    
1235            if (OK == (d == OP_HSPACE))
1236              {
1237              if (count > 0 && codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSPLUS)
1238                {
1239                active_count--;           /* Remove non-match possibility */
1240                next_active_state--;
1241                }
1242              count++;
1243              ADD_NEW_DATA(-state_offset, count, 0);
1244              }
1245          }          }
1246        break;        break;
1247    
1248        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1249    #ifdef SUPPORT_UCP
1250        case OP_PROP_EXTRA + OP_TYPEQUERY:        case OP_PROP_EXTRA + OP_TYPEQUERY:
1251        case OP_PROP_EXTRA + OP_TYPEMINQUERY:        case OP_PROP_EXTRA + OP_TYPEMINQUERY:
1252        case OP_PROP_EXTRA + OP_TYPEPOSQUERY:        case OP_PROP_EXTRA + OP_TYPEPOSQUERY:
# Line 1102  for (;;) Line 1264  for (;;)
1264        if (clen > 0)        if (clen > 0)
1265          {          {
1266          BOOL OK;          BOOL OK;
1267          int category = _pcre_ucp_findprop(c, &chartype, &script);          const ucd_record * prop = GET_UCD(c);
1268          switch(code[2])          switch(code[2])
1269            {            {
1270            case PT_ANY:            case PT_ANY:
# Line 1110  for (;;) Line 1272  for (;;)
1272            break;            break;
1273    
1274            case PT_LAMP:            case PT_LAMP:
1275            OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt;
1276            break;            break;
1277    
1278            case PT_GC:            case PT_GC:
1279            OK = category == code[3];            OK = _pcre_ucp_gentype[prop->chartype] == code[3];
1280            break;            break;
1281    
1282            case PT_PC:            case PT_PC:
1283            OK = chartype == code[3];            OK = prop->chartype == code[3];
1284            break;            break;
1285    
1286            case PT_SC:            case PT_SC:
1287            OK = script == code[3];            OK = prop->script == code[3];
1288            break;            break;
1289    
1290            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
# Line 1160  for (;;) Line 1322  for (;;)
1322        QS2:        QS2:
1323    
1324        ADD_ACTIVE(state_offset + 2, 0);        ADD_ACTIVE(state_offset + 2, 0);
1325        if (clen > 0 && _pcre_ucp_findprop(c, &chartype, &script) != ucp_M)        if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
1326          {          {
1327          const uschar *nptr = ptr + clen;          const uschar *nptr = ptr + clen;
1328          int ncount = 0;          int ncount = 0;
# Line 1175  for (;;) Line 1337  for (;;)
1337            int nd;            int nd;
1338            int ndlen = 1;            int ndlen = 1;
1339            GETCHARLEN(nd, nptr, ndlen);            GETCHARLEN(nd, nptr, ndlen);
1340            if (_pcre_ucp_findprop(nd, &chartype, &script) != ucp_M) break;            if (UCD_CATEGORY(nd) != ucp_M) break;
1341            ncount++;            ncount++;
1342            nptr += ndlen;            nptr += ndlen;
1343            }            }
1344          ADD_NEW_DATA(-(state_offset + count), 0, ncount);          ADD_NEW_DATA(-(state_offset + count), 0, ncount);
1345          }          }
1346        break;        break;
1347    #endif
1348    
1349        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1350        case OP_ANYNL_EXTRA + OP_TYPEQUERY:        case OP_ANYNL_EXTRA + OP_TYPEQUERY:
# Line 1202  for (;;) Line 1365  for (;;)
1365          int ncount = 0;          int ncount = 0;
1366          switch (c)          switch (c)
1367            {            {
1368              case 0x000b:
1369              case 0x000c:
1370              case 0x0085:
1371              case 0x2028:
1372              case 0x2029:
1373              if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1374              goto ANYNL02;
1375    
1376            case 0x000d:            case 0x000d:
1377            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1378            /* Fall through */            /* Fall through */
1379    
1380              ANYNL02:
1381              case 0x000a:
1382              if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||
1383                  codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)
1384                {
1385                active_count--;           /* Remove non-match possibility */
1386                next_active_state--;
1387                }
1388              ADD_NEW_DATA(-(state_offset + count), 0, ncount);
1389              break;
1390    
1391              default:
1392              break;
1393              }
1394            }
1395          break;
1396    
1397          /*-----------------------------------------------------------------*/
1398          case OP_VSPACE_EXTRA + OP_TYPEQUERY:
1399          case OP_VSPACE_EXTRA + OP_TYPEMINQUERY:
1400          case OP_VSPACE_EXTRA + OP_TYPEPOSQUERY:
1401          count = 2;
1402          goto QS4;
1403    
1404          case OP_VSPACE_EXTRA + OP_TYPESTAR:
1405          case OP_VSPACE_EXTRA + OP_TYPEMINSTAR:
1406          case OP_VSPACE_EXTRA + OP_TYPEPOSSTAR:
1407          count = 0;
1408    
1409          QS4:
1410          ADD_ACTIVE(state_offset + 2, 0);
1411          if (clen > 0)
1412            {
1413            BOOL OK;
1414            switch (c)
1415              {
1416            case 0x000a:            case 0x000a:
1417            case 0x000b:            case 0x000b:
1418            case 0x000c:            case 0x000c:
1419              case 0x000d:
1420            case 0x0085:            case 0x0085:
1421            case 0x2028:            case 0x2028:
1422            case 0x2029:            case 0x2029:
1423            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||            OK = TRUE;
1424                codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)            break;
1425    
1426              default:
1427              OK = FALSE;
1428              break;
1429              }
1430            if (OK == (d == OP_VSPACE))
1431              {
1432              if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSSTAR ||
1433                  codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSQUERY)
1434              {              {
1435              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1436              next_active_state--;              next_active_state--;
1437              }              }
1438            ADD_NEW_DATA(-(state_offset + count), 0, ncount);            ADD_NEW_DATA(-(state_offset + count), 0, 0);
1439              }
1440            }
1441          break;
1442    
1443          /*-----------------------------------------------------------------*/
1444          case OP_HSPACE_EXTRA + OP_TYPEQUERY:
1445          case OP_HSPACE_EXTRA + OP_TYPEMINQUERY:
1446          case OP_HSPACE_EXTRA + OP_TYPEPOSQUERY:
1447          count = 2;
1448          goto QS5;
1449    
1450          case OP_HSPACE_EXTRA + OP_TYPESTAR:
1451          case OP_HSPACE_EXTRA + OP_TYPEMINSTAR:
1452          case OP_HSPACE_EXTRA + OP_TYPEPOSSTAR:
1453          count = 0;
1454    
1455          QS5:
1456          ADD_ACTIVE(state_offset + 2, 0);
1457          if (clen > 0)
1458            {
1459            BOOL OK;
1460            switch (c)
1461              {
1462              case 0x09:      /* HT */
1463              case 0x20:      /* SPACE */
1464              case 0xa0:      /* NBSP */
1465              case 0x1680:    /* OGHAM SPACE MARK */
1466              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1467              case 0x2000:    /* EN QUAD */
1468              case 0x2001:    /* EM QUAD */
1469              case 0x2002:    /* EN SPACE */
1470              case 0x2003:    /* EM SPACE */
1471              case 0x2004:    /* THREE-PER-EM SPACE */
1472              case 0x2005:    /* FOUR-PER-EM SPACE */
1473              case 0x2006:    /* SIX-PER-EM SPACE */
1474              case 0x2007:    /* FIGURE SPACE */
1475              case 0x2008:    /* PUNCTUATION SPACE */
1476              case 0x2009:    /* THIN SPACE */
1477              case 0x200A:    /* HAIR SPACE */
1478              case 0x202f:    /* NARROW NO-BREAK SPACE */
1479              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1480              case 0x3000:    /* IDEOGRAPHIC SPACE */
1481              OK = TRUE;
1482            break;            break;
1483    
1484            default:            default:
1485              OK = FALSE;
1486            break;            break;
1487            }            }
1488    
1489            if (OK == (d == OP_HSPACE))
1490              {
1491              if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSSTAR ||
1492                  codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSQUERY)
1493                {
1494                active_count--;           /* Remove non-match possibility */
1495                next_active_state--;
1496                }
1497              ADD_NEW_DATA(-(state_offset + count), 0, 0);
1498              }
1499          }          }
1500        break;        break;
1501    
1502        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1503    #ifdef SUPPORT_UCP
1504        case OP_PROP_EXTRA + OP_TYPEEXACT:        case OP_PROP_EXTRA + OP_TYPEEXACT:
1505        case OP_PROP_EXTRA + OP_TYPEUPTO:        case OP_PROP_EXTRA + OP_TYPEUPTO:
1506        case OP_PROP_EXTRA + OP_TYPEMINUPTO:        case OP_PROP_EXTRA + OP_TYPEMINUPTO:
# Line 1236  for (;;) Line 1511  for (;;)
1511        if (clen > 0)        if (clen > 0)
1512          {          {
1513          BOOL OK;          BOOL OK;
1514          int category = _pcre_ucp_findprop(c, &chartype, &script);          const ucd_record * prop = GET_UCD(c);
1515          switch(code[4])          switch(code[4])
1516            {            {
1517            case PT_ANY:            case PT_ANY:
# Line 1244  for (;;) Line 1519  for (;;)
1519            break;            break;
1520    
1521            case PT_LAMP:            case PT_LAMP:
1522            OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;            OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll || prop->chartype == ucp_Lt;
1523            break;            break;
1524    
1525            case PT_GC:            case PT_GC:
1526            OK = category == code[5];            OK = _pcre_ucp_gentype[prop->chartype] == code[5];
1527            break;            break;
1528    
1529            case PT_PC:            case PT_PC:
1530            OK = chartype == code[5];            OK = prop->chartype == code[5];
1531            break;            break;
1532    
1533            case PT_SC:            case PT_SC:
1534            OK = script == code[5];            OK = prop->script == code[5];
1535            break;            break;
1536    
1537            /* Should never occur, but keep compilers from grumbling. */            /* Should never occur, but keep compilers from grumbling. */
# Line 1289  for (;;) Line 1564  for (;;)
1564        if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT)        if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT)
1565          { ADD_ACTIVE(state_offset + 4, 0); }          { ADD_ACTIVE(state_offset + 4, 0); }
1566        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
1567        if (clen > 0 && _pcre_ucp_findprop(c, &chartype, &script) != ucp_M)        if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
1568          {          {
1569          const uschar *nptr = ptr + clen;          const uschar *nptr = ptr + clen;
1570          int ncount = 0;          int ncount = 0;
# Line 1303  for (;;) Line 1578  for (;;)
1578            int nd;            int nd;
1579            int ndlen = 1;            int ndlen = 1;
1580            GETCHARLEN(nd, nptr, ndlen);            GETCHARLEN(nd, nptr, ndlen);
1581            if (_pcre_ucp_findprop(nd, &chartype, &script) != ucp_M) break;            if (UCD_CATEGORY(nd) != ucp_M) break;
1582            ncount++;            ncount++;
1583            nptr += ndlen;            nptr += ndlen;
1584            }            }
# Line 1313  for (;;) Line 1588  for (;;)
1588            { ADD_NEW_DATA(-state_offset, count, ncount); }            { ADD_NEW_DATA(-state_offset, count, ncount); }
1589          }          }
1590        break;        break;
1591    #endif
1592    
1593        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1594        case OP_ANYNL_EXTRA + OP_TYPEEXACT:        case OP_ANYNL_EXTRA + OP_TYPEEXACT:
# Line 1327  for (;;) Line 1603  for (;;)
1603          int ncount = 0;          int ncount = 0;
1604          switch (c)          switch (c)
1605            {            {
1606              case 0x000b:
1607              case 0x000c:
1608              case 0x0085:
1609              case 0x2028:
1610              case 0x2029:
1611              if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1612              goto ANYNL03;
1613    
1614            case 0x000d:            case 0x000d:
1615            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;            if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1616            /* Fall through */            /* Fall through */
1617    
1618              ANYNL03:
1619              case 0x000a:
1620              if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)
1621                {
1622                active_count--;           /* Remove non-match possibility */
1623                next_active_state--;
1624                }
1625              if (++count >= GET2(code, 1))
1626                { ADD_NEW_DATA(-(state_offset + 4), 0, ncount); }
1627              else
1628                { ADD_NEW_DATA(-state_offset, count, ncount); }
1629              break;
1630    
1631              default:
1632              break;
1633              }
1634            }
1635          break;
1636    
1637          /*-----------------------------------------------------------------*/
1638          case OP_VSPACE_EXTRA + OP_TYPEEXACT:
1639          case OP_VSPACE_EXTRA + OP_TYPEUPTO:
1640          case OP_VSPACE_EXTRA + OP_TYPEMINUPTO:
1641          case OP_VSPACE_EXTRA + OP_TYPEPOSUPTO:
1642          if (codevalue != OP_VSPACE_EXTRA + OP_TYPEEXACT)
1643            { ADD_ACTIVE(state_offset + 4, 0); }
1644          count = current_state->count;  /* Number already matched */
1645          if (clen > 0)
1646            {
1647            BOOL OK;
1648            switch (c)
1649              {
1650            case 0x000a:            case 0x000a:
1651            case 0x000b:            case 0x000b:
1652            case 0x000c:            case 0x000c:
1653              case 0x000d:
1654            case 0x0085:            case 0x0085:
1655            case 0x2028:            case 0x2028:
1656            case 0x2029:            case 0x2029:
1657            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)            OK = TRUE;
1658              break;
1659    
1660              default:
1661              OK = FALSE;
1662              }
1663    
1664            if (OK == (d == OP_VSPACE))
1665              {
1666              if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSUPTO)
1667              {              {
1668              active_count--;           /* Remove non-match possibility */              active_count--;           /* Remove non-match possibility */
1669              next_active_state--;              next_active_state--;
1670              }              }
1671            if (++count >= GET2(code, 1))            if (++count >= GET2(code, 1))
1672              { ADD_NEW_DATA(-(state_offset + 4), 0, ncount); }              { ADD_NEW_DATA(-(state_offset + 4), 0, 0); }
1673            else            else
1674              { ADD_NEW_DATA(-state_offset, count, ncount); }              { ADD_NEW_DATA(-state_offset, count, 0); }
1675              }
1676            }
1677          break;
1678    
1679          /*-----------------------------------------------------------------*/
1680          case OP_HSPACE_EXTRA + OP_TYPEEXACT:
1681          case OP_HSPACE_EXTRA + OP_TYPEUPTO:
1682          case OP_HSPACE_EXTRA + OP_TYPEMINUPTO:
1683          case OP_HSPACE_EXTRA + OP_TYPEPOSUPTO:
1684          if (codevalue != OP_HSPACE_EXTRA + OP_TYPEEXACT)
1685            { ADD_ACTIVE(state_offset + 4, 0); }
1686          count = current_state->count;  /* Number already matched */
1687          if (clen > 0)
1688            {
1689            BOOL OK;
1690            switch (c)
1691              {
1692              case 0x09:      /* HT */
1693              case 0x20:      /* SPACE */
1694              case 0xa0:      /* NBSP */
1695              case 0x1680:    /* OGHAM SPACE MARK */
1696              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1697              case 0x2000:    /* EN QUAD */
1698              case 0x2001:    /* EM QUAD */
1699              case 0x2002:    /* EN SPACE */
1700              case 0x2003:    /* EM SPACE */
1701              case 0x2004:    /* THREE-PER-EM SPACE */
1702              case 0x2005:    /* FOUR-PER-EM SPACE */
1703              case 0x2006:    /* SIX-PER-EM SPACE */
1704              case 0x2007:    /* FIGURE SPACE */
1705              case 0x2008:    /* PUNCTUATION SPACE */
1706              case 0x2009:    /* THIN SPACE */
1707              case 0x200A:    /* HAIR SPACE */
1708              case 0x202f:    /* NARROW NO-BREAK SPACE */
1709              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1710              case 0x3000:    /* IDEOGRAPHIC SPACE */
1711              OK = TRUE;
1712            break;            break;
1713    
1714            default:            default:
1715              OK = FALSE;
1716            break;            break;
1717            }            }
1718    
1719            if (OK == (d == OP_HSPACE))
1720              {
1721              if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSUPTO)
1722                {
1723                active_count--;           /* Remove non-match possibility */
1724                next_active_state--;
1725                }
1726              if (++count >= GET2(code, 1))
1727                { ADD_NEW_DATA(-(state_offset + 4), 0, 0); }
1728              else
1729                { ADD_NEW_DATA(-state_offset, count, 0); }
1730              }
1731          }          }
1732        break;        break;
1733    
# Line 1379  for (;;) Line 1758  for (;;)
1758            other case of the character. */            other case of the character. */
1759    
1760  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
1761            othercase = _pcre_ucp_othercase(c);            othercase = UCD_OTHERCASE(c);
1762  #else  #else
1763            othercase = NOTACHAR;            othercase = NOTACHAR;
1764  #endif  #endif
# Line 1404  for (;;) Line 1783  for (;;)
1783        to wait for them to pass before continuing. */        to wait for them to pass before continuing. */
1784    
1785        case OP_EXTUNI:        case OP_EXTUNI:
1786        if (clen > 0 && _pcre_ucp_findprop(c, &chartype, &script) != ucp_M)        if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
1787          {          {
1788          const uschar *nptr = ptr + clen;          const uschar *nptr = ptr + clen;
1789          int ncount = 0;          int ncount = 0;
# Line 1412  for (;;) Line 1791  for (;;)
1791            {            {
1792            int nclen = 1;            int nclen = 1;
1793            GETCHARLEN(c, nptr, nclen);            GETCHARLEN(c, nptr, nclen);
1794            if (_pcre_ucp_findprop(c, &chartype, &script) != ucp_M) break;            if (UCD_CATEGORY(c) != ucp_M) break;
1795            ncount++;            ncount++;
1796            nptr += nclen;            nptr += nclen;
1797            }            }
# Line 1429  for (;;) Line 1808  for (;;)
1808        case OP_ANYNL:        case OP_ANYNL:
1809        if (clen > 0) switch(c)        if (clen > 0) switch(c)
1810          {          {
         case 0x000a:  
1811          case 0x000b:          case 0x000b:
1812          case 0x000c:          case 0x000c:
1813          case 0x0085:          case 0x0085:
1814          case 0x2028:          case 0x2028:
1815          case 0x2029:          case 0x2029:
1816            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1817    
1818            case 0x000a:
1819          ADD_NEW(state_offset + 1, 0);          ADD_NEW(state_offset + 1, 0);
1820          break;          break;
1821    
1822          case 0x000d:          case 0x000d:
1823          if (ptr + 1 < end_subject && ptr[1] == 0x0a)          if (ptr + 1 < end_subject && ptr[1] == 0x0a)
1824            {            {
# Line 1451  for (;;) Line 1833  for (;;)
1833        break;        break;
1834    
1835        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1836          case OP_NOT_VSPACE:
1837          if (clen > 0) switch(c)
1838            {
1839            case 0x000a:
1840            case 0x000b:
1841            case 0x000c:
1842            case 0x000d:
1843            case 0x0085:
1844            case 0x2028:
1845            case 0x2029:
1846            break;
1847    
1848            default:
1849            ADD_NEW(state_offset + 1, 0);
1850            break;
1851            }
1852          break;
1853    
1854          /*-----------------------------------------------------------------*/
1855          case OP_VSPACE:
1856          if (clen > 0) switch(c)
1857            {
1858            case 0x000a:
1859            case 0x000b:
1860            case 0x000c:
1861            case 0x000d:
1862            case 0x0085:
1863            case 0x2028:
1864            case 0x2029:
1865            ADD_NEW(state_offset + 1, 0);
1866            break;
1867    
1868            default: break;
1869            }
1870          break;
1871    
1872          /*-----------------------------------------------------------------*/
1873          case OP_NOT_HSPACE:
1874          if (clen > 0) switch(c)
1875            {
1876            case 0x09:      /* HT */
1877            case 0x20:      /* SPACE */
1878            case 0xa0:      /* NBSP */
1879            case 0x1680:    /* OGHAM SPACE MARK */
1880            case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1881            case 0x2000:    /* EN QUAD */
1882            case 0x2001:    /* EM QUAD */
1883            case 0x2002:    /* EN SPACE */
1884            case 0x2003:    /* EM SPACE */
1885            case 0x2004:    /* THREE-PER-EM SPACE */
1886            case 0x2005:    /* FOUR-PER-EM SPACE */
1887            case 0x2006:    /* SIX-PER-EM SPACE */
1888            case 0x2007:    /* FIGURE SPACE */
1889            case 0x2008:    /* PUNCTUATION SPACE */
1890            case 0x2009:    /* THIN SPACE */
1891            case 0x200A:    /* HAIR SPACE */
1892            case 0x202f:    /* NARROW NO-BREAK SPACE */
1893            case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1894            case 0x3000:    /* IDEOGRAPHIC SPACE */
1895            break;
1896    
1897            default:
1898            ADD_NEW(state_offset + 1, 0);
1899            break;
1900            }
1901          break;
1902    
1903          /*-----------------------------------------------------------------*/
1904          case OP_HSPACE:
1905          if (clen > 0) switch(c)
1906            {
1907            case 0x09:      /* HT */
1908            case 0x20:      /* SPACE */
1909            case 0xa0:      /* NBSP */
1910            case 0x1680:    /* OGHAM SPACE MARK */
1911            case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1912            case 0x2000:    /* EN QUAD */
1913            case 0x2001:    /* EM QUAD */
1914            case 0x2002:    /* EN SPACE */
1915            case 0x2003:    /* EM SPACE */
1916            case 0x2004:    /* THREE-PER-EM SPACE */
1917            case 0x2005:    /* FOUR-PER-EM SPACE */
1918            case 0x2006:    /* SIX-PER-EM SPACE */
1919            case 0x2007:    /* FIGURE SPACE */
1920            case 0x2008:    /* PUNCTUATION SPACE */
1921            case 0x2009:    /* THIN SPACE */
1922            case 0x200A:    /* HAIR SPACE */
1923            case 0x202f:    /* NARROW NO-BREAK SPACE */
1924            case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1925            case 0x3000:    /* IDEOGRAPHIC SPACE */
1926            ADD_NEW(state_offset + 1, 0);
1927            break;
1928            }
1929          break;
1930    
1931          /*-----------------------------------------------------------------*/
1932        /* Match a negated single character. This is only used for one-byte        /* Match a negated single character. This is only used for one-byte
1933        characters, that is, we know that d < 256. The character we are        characters, that is, we know that d < 256. The character we are
1934        checking (c) can be multibyte. */        checking (c) can be multibyte. */
# Line 1481  for (;;) Line 1959  for (;;)
1959            if (utf8 && d >= 128)            if (utf8 && d >= 128)
1960              {              {
1961  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
1962              otherd = _pcre_ucp_othercase(d);              otherd = UCD_OTHERCASE(d);
1963  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
1964              }              }
1965            else            else
# Line 1519  for (;;) Line 1997  for (;;)
1997            if (utf8 && d >= 128)            if (utf8 && d >= 128)
1998              {              {
1999  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2000              otherd = _pcre_ucp_othercase(d);              otherd = UCD_OTHERCASE(d);
2001  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2002              }              }
2003            else            else
# Line 1555  for (;;) Line 2033  for (;;)
2033            if (utf8 && d >= 128)            if (utf8 && d >= 128)
2034              {              {
2035  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2036              otherd = _pcre_ucp_othercase(d);              otherd = UCD_OTHERCASE(d);
2037  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2038              }              }
2039            else            else
# Line 1587  for (;;) Line 2065  for (;;)
2065            if (utf8 && d >= 128)            if (utf8 && d >= 128)
2066              {              {
2067  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2068              otherd = _pcre_ucp_othercase(d);              otherd = UCD_OTHERCASE(d);
2069  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2070              }              }
2071            else            else
# Line 1622  for (;;) Line 2100  for (;;)
2100            if (utf8 && d >= 128)            if (utf8 && d >= 128)
2101              {              {
2102  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2103              otherd = _pcre_ucp_othercase(d);              otherd = UCD_OTHERCASE(d);
2104  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2105              }              }
2106            else            else
# Line 1730  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. */        to use recursion in order to handle them. The "always failing" assertion
2212          (?!) is optimised to OP_FAIL when compiling, so we have to support that,
2213          though the other "backtracking verbs" are not supported. */
2214    
2215          case OP_FAIL:
2216          forced_fail++;    /* Count FAILs for multiple states */
2217          break;
2218    
2219        case OP_ASSERT:        case OP_ASSERT:
2220        case OP_ASSERT_NOT:        case OP_ASSERT_NOT:
# Line 1768  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    
# Line 1777  for (;;) Line 2292  for (;;)
2292          /* The DEFINE condition is always false */          /* The DEFINE condition is always false */
2293    
2294          if (condcode == OP_DEF)          if (condcode == OP_DEF)
2295            {            { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
           ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0);  
           }  
2296    
2297          /* 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,
2298          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
# Line 1789  for (;;) Line 2302  for (;;)
2302            {            {
2303            int value = GET2(code, LINK_SIZE+2);            int value = GET2(code, LINK_SIZE+2);
2304            if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;            if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;
2305            if (recursing > 0) { ADD_ACTIVE(state_offset + LINK_SIZE + 4, 0); }            if (recursing > 0)
2306              else { ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0); }              { ADD_ACTIVE(state_offset + LINK_SIZE + 4, 0); }
2307              else { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
2308            }            }
2309    
2310          /* Otherwise, the condition is an assertion */          /* Otherwise, the condition is an assertion */
# Line 1820  for (;;) Line 2334  for (;;)
2334                  (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))                  (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))
2335              { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }              { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }
2336            else            else
2337              { ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0); }              { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
2338            }            }
2339          }          }
2340        break;        break;
# Line 1972  for (;;) Line 2486  for (;;)
2486        /* Handle callouts */        /* Handle callouts */
2487    
2488        case OP_CALLOUT:        case OP_CALLOUT:
2489          rrc = 0;
2490        if (pcre_callout != NULL)        if (pcre_callout != NULL)
2491          {          {
         int rrc;  
2492          pcre_callout_block cb;          pcre_callout_block cb;
2493          cb.version          = 1;   /* Version 1 of the callout block */          cb.version          = 1;   /* Version 1 of the callout block */
2494          cb.callout_number   = code[1];          cb.callout_number   = code[1];
# Line 1989  for (;;) Line 2503  for (;;)
2503          cb.capture_last     = -1;          cb.capture_last     = -1;
2504          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
2505          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); }  
2506          }          }
2507          if (rrc == 0)
2508            { ADD_ACTIVE(state_offset + _pcre_OP_lengths[OP_CALLOUT], 0); }
2509        break;        break;
2510    
2511    
# Line 2006  for (;;) Line 2521  for (;;)
2521    /* We have finished the processing at the current subject character. If no    /* We have finished the processing at the current subject character. If no
2522    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
2523    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
2524    matching has been requested, check for appropriate conditions. */    matching has been requested, check for appropriate conditions. The "forced_
2525      fail" variable counts the number of (*F) encountered for the character. If it
2526      is equal to the original active_count (saved in workspace[1]) it means that
2527      (*F) was found on every active state. In this case we don't want to give a
2528      partial match. */
2529    
2530    if (new_count <= 0)    if (new_count <= 0)
2531      {      {
2532      if (match_count < 0 &&                     /* No matches found */      if (rlevel == 1 &&                               /* Top level, and */
2533          rlevel == 1 &&                         /* Top level match function */          reached_end != workspace[1] &&               /* Not all reached end */
2534          (md->moptions & PCRE_PARTIAL) != 0 &&  /* Want partial matching */          forced_fail != workspace[1] &&               /* Not all forced fail & */
2535          ptr >= end_subject &&                  /* Reached end of subject */          (                                            /* either... */
2536          ptr > current_subject)                 /* Matched non-empty string */          (md->moptions & PCRE_PARTIAL_HARD) != 0      /* Hard partial */
2537            ||                                           /* or... */
2538            ((md->moptions & PCRE_PARTIAL_SOFT) != 0 &&  /* Soft partial and */
2539             match_count < 0)                            /* no matches */
2540            ) &&                                         /* And... */
2541            ptr >= end_subject &&                     /* Reached end of subject */
2542            ptr > current_subject)                    /* Matched non-empty string */
2543        {        {
2544        if (offsetcount >= 2)        if (offsetcount >= 2)
2545          {          {
2546          offsets[0] = current_subject - start_subject;          offsets[0] = md->start_used_ptr - start_subject;
2547          offsets[1] = end_subject - start_subject;          offsets[1] = end_subject - start_subject;
2548          }          }
2549        match_count = PCRE_ERROR_PARTIAL;        match_count = PCRE_ERROR_PARTIAL;
# Line 2057  is not anchored. Line 2582  is not anchored.
2582    
2583  Arguments:  Arguments:
2584    argument_re     points to the compiled expression    argument_re     points to the compiled expression
2585    extra_data      points to extra data or is NULL (not currently used)    extra_data      points to extra data or is NULL
2586    subject         points to the subject string    subject         points to the subject string
2587    length          length of subject string (may contain binary zeros)    length          length of subject string (may contain binary zeros)
2588    start_offset    where to start in the subject string    start_offset    where to start in the subject string
# Line 2073  Returns: > 0 => number of match Line 2598  Returns: > 0 => number of match
2598                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
2599  */  */
2600    
2601  PCRE_DATA_SCOPE int  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
2602  pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,
2603    const char *subject, int length, int start_offset, int options, int *offsets,    const char *subject, int length, int start_offset, int options, int *offsets,
2604    int offsetcount, int *workspace, int wscount)    int offsetcount, int *workspace, int wscount)
# Line 2160  md->start_code = (const uschar *)argumen Line 2685  md->start_code = (const uschar *)argumen
2685      re->name_table_offset + re->name_count * re->name_entry_size;      re->name_table_offset + re->name_count * re->name_entry_size;
2686  md->start_subject = (const unsigned char *)subject;  md->start_subject = (const unsigned char *)subject;
2687  md->end_subject = end_subject;  md->end_subject = end_subject;
2688    md->start_offset = start_offset;
2689  md->moptions = options;  md->moptions = options;
2690  md->poptions = re->options;  md->poptions = re->options;
2691    
2692  /* Handle different types of newline. The two bits give four cases. If nothing  /* If the BSR option is not set at match time, copy what was set
2693  is set at run time, whatever was used at compile time applies. */  at compile time. */
2694    
2695    if ((md->moptions & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) == 0)
2696      {
2697      if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
2698        md->moptions |= re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE);
2699    #ifdef BSR_ANYCRLF
2700      else md->moptions |= PCRE_BSR_ANYCRLF;
2701    #endif
2702      }
2703    
2704    /* Handle different types of newline. The three bits give eight cases. If
2705    nothing is set at run time, whatever was used at compile time applies. */
2706    
2707  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : options) &  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &
2708           PCRE_NEWLINE_BITS)           PCRE_NEWLINE_BITS)
2709    {    {
2710    case 0: newline = NEWLINE; break;   /* Compile-time default */    case 0: newline = NEWLINE; break;   /* Compile-time default */
2711    case PCRE_NEWLINE_CR: newline = '\r'; break;    case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
2712    case PCRE_NEWLINE_LF: newline = '\n'; break;    case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
2713    case PCRE_NEWLINE_CR+    case PCRE_NEWLINE_CR+
2714         PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;         PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
2715    case PCRE_NEWLINE_ANY: newline = -1; break;    case PCRE_NEWLINE_ANY: newline = -1; break;
2716      case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
2717    default: return PCRE_ERROR_BADNEWLINE;    default: return PCRE_ERROR_BADNEWLINE;
2718    }    }
2719    
2720  if (newline < 0)  if (newline == -2)
2721      {
2722      md->nltype = NLTYPE_ANYCRLF;
2723      }
2724    else if (newline < 0)
2725    {    {
2726    md->nltype = NLTYPE_ANY;    md->nltype = NLTYPE_ANY;
2727    }    }
# Line 2228  if (md->tables == NULL) md->tables = _pc Line 2771  if (md->tables == NULL) md->tables = _pc
2771  used in a loop when finding where to start. */  used in a loop when finding where to start. */
2772    
2773  lcc = md->tables + lcc_offset;  lcc = md->tables + lcc_offset;
2774  startline = (re->options & PCRE_STARTLINE) != 0;  startline = (re->flags & PCRE_STARTLINE) != 0;
2775  firstline = (re->options & PCRE_FIRSTLINE) != 0;  firstline = (re->options & PCRE_FIRSTLINE) != 0;
2776    
2777  /* Set up the first character to match, if available. The first_byte value is  /* Set up the first character to match, if available. The first_byte value is
# Line 2239  studied, there may be a bitmap of possib Line 2782  studied, there may be a bitmap of possib
2782    
2783  if (!anchored)  if (!anchored)
2784    {    {
2785    if ((re->options & PCRE_FIRSTSET) != 0)    if ((re->flags & PCRE_FIRSTSET) != 0)
2786      {      {
2787      first_byte = re->first_byte & 255;      first_byte = re->first_byte & 255;
2788      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
# Line 2256  if (!anchored) Line 2799  if (!anchored)
2799  /* For anchored or unanchored matches, there may be a "last known required  /* For anchored or unanchored matches, there may be a "last known required
2800  character" set. */  character" set. */
2801    
2802  if ((re->options & PCRE_REQCHSET) != 0)  if ((re->flags & PCRE_REQCHSET) != 0)
2803    {    {
2804    req_byte = re->req_byte & 255;    req_byte = re->req_byte & 255;
2805    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
# Line 2264  if ((re->options & PCRE_REQCHSET) != 0) Line 2807  if ((re->options & PCRE_REQCHSET) != 0)
2807    }    }
2808    
2809  /* 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
2810  failed match. Unless restarting, optimize by moving to the first match  failed match. If not restarting, perform certain optimizations at the start of
2811  character if possible, when not anchored. Then unless wanting a partial match,  a match. */
 check for a required later character. */  
2812    
2813  for (;;)  for (;;)
2814    {    {
# Line 2276  for (;;) Line 2818  for (;;)
2818      {      {
2819      const uschar *save_end_subject = end_subject;      const uschar *save_end_subject = end_subject;
2820    
2821      /* 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
2822      start of the match is constrained to the first line of a multiline string.      line of a multiline string. Implement this by temporarily adjusting
2823      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
2824      scanning at a newline. If the match fails at the newline, later code breaks      the newline, later code breaks this loop. */
     this loop. */  
2825    
2826      if (firstline)      if (firstline)
2827        {        {
2828        const uschar *t = current_subject;        USPTR t = current_subject;
2829    #ifdef SUPPORT_UTF8
2830          if (utf8)
2831            {
2832            while (t < md->end_subject && !IS_NEWLINE(t))
2833              {
2834              t++;
2835              while (t < end_subject && (*t & 0xc0) == 0x80) t++;
2836              }
2837            }
2838          else
2839    #endif
2840        while (t < md->end_subject && !IS_NEWLINE(t)) t++;        while (t < md->end_subject && !IS_NEWLINE(t)) t++;
2841        end_subject = t;        end_subject = t;
2842        }        }
2843    
2844      if (first_byte >= 0)      /* There are some optimizations that avoid running the match if a known
2845        starting point is not found, or if a known later character is not present.
2846        However, there is an option that disables these, for testing and for
2847        ensuring that all callouts do actually occur. */
2848    
2849        if ((options & PCRE_NO_START_OPTIMIZE) == 0)
2850        {        {
       if (first_byte_caseless)  
         while (current_subject < end_subject &&  
                lcc[*current_subject] != first_byte)  
           current_subject++;  
       else  
         while (current_subject < end_subject && *current_subject != first_byte)  
           current_subject++;  
       }  
2851    
2852      /* Or to just after a linebreak for a multiline match if possible */        /* Advance to a known first byte. */
2853    
2854      else if (startline)        if (first_byte >= 0)
       {  
       if (current_subject > md->start_subject + start_offset)  
2855          {          {
2856          while (current_subject <= end_subject && !WAS_NEWLINE(current_subject))          if (first_byte_caseless)
2857            current_subject++;            while (current_subject < end_subject &&
2858                     lcc[*current_subject] != first_byte)
2859                current_subject++;
2860            else
2861              while (current_subject < end_subject &&
2862                     *current_subject != first_byte)
2863                current_subject++;
2864          }          }
       }  
2865    
2866      /* Or to a non-unique first char after study */        /* Or to just after a linebreak for a multiline match if possible */
2867    
2868      else if (start_bits != NULL)        else if (startline)
2869        {          {
2870        while (current_subject < end_subject)          if (current_subject > md->start_subject + start_offset)
2871              {
2872    #ifdef SUPPORT_UTF8
2873              if (utf8)
2874                {
2875                while (current_subject < end_subject &&
2876                       !WAS_NEWLINE(current_subject))
2877                  {
2878                  current_subject++;
2879                  while(current_subject < end_subject &&
2880                        (*current_subject & 0xc0) == 0x80)
2881                    current_subject++;
2882                  }
2883                }
2884              else
2885    #endif
2886              while (current_subject < end_subject && !WAS_NEWLINE(current_subject))
2887                current_subject++;
2888    
2889              /* If we have just passed a CR and the newline option is ANY or
2890              ANYCRLF, and we are now at a LF, advance the match position by one
2891              more character. */
2892    
2893              if (current_subject[-1] == CHAR_CR &&
2894                   (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
2895                   current_subject < end_subject &&
2896                   *current_subject == CHAR_NL)
2897                current_subject++;
2898              }
2899            }
2900    
2901          /* Or to a non-unique first char after study */
2902    
2903          else if (start_bits != NULL)
2904          {          {
2905          register unsigned int c = *current_subject;          while (current_subject < end_subject)
2906          if ((start_bits[c/8] & (1 << (c&7))) == 0) current_subject++;            {
2907            else break;            register unsigned int c = *current_subject;
2908              if ((start_bits[c/8] & (1 << (c&7))) == 0) current_subject++;
2909                else break;
2910              }
2911          }          }
2912        }        }
2913    
# Line 2341  for (;;) Line 2929  for (;;)
2929    showed up when somebody was matching /^C/ on a 32-megabyte string... so we    showed up when somebody was matching /^C/ on a 32-megabyte string... so we
2930    don't do this when the string is sufficiently long.    don't do this when the string is sufficiently long.
2931    
2932    ALSO: this processing is disabled when partial matching is requested.    ALSO: this processing is disabled when partial matching is requested, and can
2933    */    also be explicitly deactivated. Furthermore, we have to disable when
2934      restarting after a partial match, because the required character may have
2935      already been matched. */
2936    
2937    if (req_byte >= 0 &&    if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&
2938          req_byte >= 0 &&
2939        end_subject - current_subject < REQ_BYTE_MAX &&        end_subject - current_subject < REQ_BYTE_MAX &&
2940        (options & PCRE_PARTIAL) == 0)        (options & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT|PCRE_DFA_RESTART)) == 0)
2941      {      {
2942      register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);      register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);
2943    
# Line 2386  for (;;) Line 2977  for (;;)
2977    
2978    /* OK, now we can do the business */    /* OK, now we can do the business */
2979    
2980      md->start_used_ptr = current_subject;
2981    
2982    rc = internal_dfa_exec(    rc = internal_dfa_exec(
2983      md,                                /* fixed match data */      md,                                /* fixed match data */
2984      md->start_code,                    /* this subexpression's code */      md->start_code,                    /* this subexpression's code */
# Line 2416  for (;;) Line 3009  for (;;)
3009      }      }
3010    if (current_subject > end_subject) break;    if (current_subject > end_subject) break;
3011    
3012    /* If we have just passed a CR and the newline option is CRLF or ANY, and we    /* If we have just passed a CR and we are now at a LF, and the pattern does
3013    are now at a LF, advance the match position by one more character. */    not contain any explicit matches for \r or \n, and the newline option is CRLF
3014      or ANY or ANYCRLF, advance the match position by one more character. */
3015    if (current_subject[-1] == '\r' &&  
3016         (md->nltype == NLTYPE_ANY || md->nllen == 2) &&    if (current_subject[-1] == CHAR_CR &&
3017         current_subject < end_subject &&        current_subject < end_subject &&
3018         *current_subject == '\n')        *current_subject == CHAR_NL &&
3019          (re->flags & PCRE_HASCRORLF) == 0 &&
3020            (md->nltype == NLTYPE_ANY ||
3021             md->nltype == NLTYPE_ANYCRLF ||
3022             md->nllen == 2))
3023      current_subject++;      current_subject++;
3024    
3025    }   /* "Bumpalong" loop */    }   /* "Bumpalong" loop */

Legend:
Removed from v.93  
changed lines
  Added in v.442

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12