/[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 91 by nigel, Sat Feb 24 21:41:34 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 39  POSSIBILITY OF SUCH DAMAGE. Line 40  POSSIBILITY OF SUCH DAMAGE.
40    
41    
42  /* This module contains the external function pcre_dfa_exec(), which is an  /* This module contains the external function pcre_dfa_exec(), which is an
43  alternative matching function that uses a DFA algorithm. This is NOT Perl-  alternative matching function that uses a sort of DFA algorithm (not a true
44  compatible, but it has advantages in certain applications. */  FSM). This is NOT Perl- compatible, but it has advantages in certain
45    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 */
81    #define PSSTART start_subject  /* Field containing processed string start */
82    #define PSEND   end_subject    /* Field containing processed string end */
83    
 #define NLBLOCK md           /* The block containing newline information */  
84  #include "pcre_internal.h"  #include "pcre_internal.h"
85    
86    
# Line 52  compatible, but it has advantages in cer Line 89  compatible, but it has advantages in cer
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 10 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  #define OP_PROP_EXTRA    (EXTRACT_BASIC_MAX+1)  
101  #define OP_EXTUNI_EXTRA  (EXTRACT_BASIC_MAX+11)  #define OP_PROP_EXTRA       300
102    #define OP_EXTUNI_EXTRA     320
103    #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,                       /* Any, AllAny, Anybyte                   */
120    0, 0, 0,                       /* NOTPROP, PROP, EXTUNI                  */    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 83  static uschar coptable[] = { Line 126  static uschar coptable[] = {
126    /* Positive single-char repeats                                          */    /* Positive single-char repeats                                          */
127    1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */    1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
128    3, 3, 3,                       /* upto, minupto, exact                   */    3, 3, 3,                       /* upto, minupto, exact                   */
129      1, 1, 1, 3,                    /* *+, ++, ?+, upto+                      */
130    /* Negative single-char repeats - only for chars < 256                   */    /* Negative single-char repeats - only for chars < 256                   */
131    1, 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */    1, 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */
132    3, 3, 3,                       /* NOT upto, minupto, exact               */    3, 3, 3,                       /* NOT upto, minupto, exact               */
133      1, 1, 1, 3,                    /* NOT *+, ++, ?+, updo+                  */
134    /* Positive type repeats                                                 */    /* Positive type repeats                                                 */
135    1, 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */    1, 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */
136    3, 3, 3,                       /* Type upto, minupto, exact              */    3, 3, 3,                       /* Type upto, minupto, exact              */
137      1, 1, 1, 3,                    /* Type *+, ++, ?+, upto+                 */
138    /* Character class & ref repeats                                         */    /* Character class & ref repeats                                         */
139    0, 0, 0, 0, 0, 0,              /* *, *?, +, +?, ?, ??                    */    0, 0, 0, 0, 0, 0,              /* *, *?, +, +?, ?, ??                    */
140    0, 0,                          /* CRRANGE, CRMINRANGE                    */    0, 0,                          /* CRRANGE, CRMINRANGE                    */
# Line 107  static uschar coptable[] = { Line 153  static uschar coptable[] = {
153    0,                             /* Assert behind                          */    0,                             /* Assert behind                          */
154    0,                             /* Assert behind not                      */    0,                             /* Assert behind not                      */
155    0,                             /* Reverse                                */    0,                             /* Reverse                                */
156    0,                             /* Once                                   */    0, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */
157    0,                             /* COND                                   */    0, 0, 0,                       /* SBRA, SCBRA, SCOND                     */
158    0,                             /* CREF                                   */    0,                             /* CREF                                   */
159      0,                             /* RREF                                   */
160      0,                             /* DEF                                    */
161    0, 0,                          /* BRAZERO, BRAMINZERO                    */    0, 0,                          /* BRAZERO, BRAMINZERO                    */
162    0,                             /* BRANUMBER                              */    0, 0, 0, 0,                    /* PRUNE, SKIP, THEN, COMMIT              */
163    0                              /* BRA                                    */    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 203  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 278  stateblock *next_active_state, *next_new Line 326  stateblock *next_active_state, *next_new
326    
327  const uschar *ctypes, *lcc, *fcc;  const uschar *ctypes, *lcc, *fcc;
328  const uschar *ptr;  const uschar *ptr;
329  const uschar *end_code;  const uschar *end_code, *first_op;
330    
331  int active_count, new_count, match_count;  int active_count, new_count, match_count;
332    
# Line 291  const uschar *start_code = md->start_cod Line 339  const uschar *start_code = md->start_cod
339    
340  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
341  BOOL utf8 = (md->poptions & PCRE_UTF8) != 0;  BOOL utf8 = (md->poptions & PCRE_UTF8) != 0;
342    #else
343    BOOL utf8 = FALSE;
344  #endif  #endif
345    
346  rlevel++;  rlevel++;
# Line 314  active_states = (stateblock *)(workspace Line 364  active_states = (stateblock *)(workspace
364  next_new_state = new_states = active_states + wscount;  next_new_state = new_states = active_states + wscount;
365  new_count = 0;  new_count = 0;
366    
367    first_op = this_start_code + 1 + LINK_SIZE +
368      ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);
369    
370  /* The first thing in any (sub) pattern is a bracket of some sort. Push all  /* The first thing in any (sub) pattern is a bracket of some sort. Push all
371  the alternative states onto the list, and find out where the end is. This  the alternative states onto the list, and find out where the end is. This
372  makes is possible to use this function recursively, when we want to stop at a  makes is possible to use this function recursively, when we want to stop at a
# Line 323  If the first opcode in the first alterna Line 376  If the first opcode in the first alterna
376  a backward assertion. In that case, we have to find out the maximum amount to  a backward assertion. In that case, we have to find out the maximum amount to
377  move back, and set up each alternative appropriately. */  move back, and set up each alternative appropriately. */
378    
379  if (this_start_code[1+LINK_SIZE] == OP_REVERSE)  if (*first_op == OP_REVERSE)
380    {    {
381    int max_back = 0;    int max_back = 0;
382    int gone_back;    int gone_back;
# Line 364  if (this_start_code[1+LINK_SIZE] == OP_R Line 417  if (this_start_code[1+LINK_SIZE] == OP_R
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 405  else Line 463  else
463    
464    else    else
465      {      {
466        int length = 1 + LINK_SIZE +
467          ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);
468      do      do
469        {        {
470        ADD_NEW(end_code - start_code + 1 + LINK_SIZE, 0);        ADD_NEW(end_code - start_code + length, 0);
471        end_code += GET(end_code, 1);        end_code += GET(end_code, 1);
472          length = 1 + LINK_SIZE;
473        }        }
474      while (*end_code == OP_ALT);      while (*end_code == OP_ALT);
475      }      }
# Line 426  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 461  for (;;) Line 524  for (;;)
524    
525    if (ptr < end_subject)    if (ptr < end_subject)
526      {      {
527      clen = 1;      clen = 1;        /* Number of bytes in the character */
528  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
529      if (utf8) { GETCHARLEN(c, ptr, clen); } else      if (utf8) { GETCHARLEN(c, ptr, clen); } else
530  #endif  /* SUPPORT_UTF8 */  #endif  /* SUPPORT_UTF8 */
# Line 469  for (;;) Line 532  for (;;)
532      }      }
533    else    else
534      {      {
535      clen = 0;    /* At end subject */      clen = 0;        /* This indicates the end of the subject */
536      c = -1;      c = NOTACHAR;    /* This value should never actually be used */
537      }      }
538    
539    /* Scan up the active states and act on each one. The result of an action    /* Scan up the active states and act on each one. The result of an action
# Line 483  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);
553      if (c < 0) printf("-1\n");      if (clen == 0) printf("EOL\n");
554        else if (c > 32 && c < 127) printf("'%c'\n", c);        else if (c > 32 && c < 127) printf("'%c'\n", c);
555          else printf("0x%02x\n", c);          else printf("0x%02x\n", c);
556  #endif  #endif
# Line 516  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 532  for (;;) Line 596  for (;;)
596    
597      code = start_code + state_offset;      code = start_code + state_offset;
598      codevalue = *code;      codevalue = *code;
     if (codevalue >= OP_BRA) codevalue = OP_BRA; /* All brackets are equal */  
599    
600      /* 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
601      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
# Line 540  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 554  for (;;) Line 617  for (;;)
617        d = code[coptable[codevalue]];        d = code[coptable[codevalue]];
618        if (codevalue >= OP_TYPESTAR)        if (codevalue >= OP_TYPESTAR)
619          {          {
620          if (d == OP_ANYBYTE) return PCRE_ERROR_DFA_UITEM;          switch(d)
621          if (d >= OP_NOTPROP)            {
622            codevalue += (d == OP_EXTUNI)? OP_EXTUNI_EXTRA : OP_PROP_EXTRA;            case OP_ANYBYTE: return PCRE_ERROR_DFA_UITEM;
623              case OP_NOTPROP:
624              case OP_PROP: codevalue += OP_PROP_EXTRA; break;
625              case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break;
626              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;
632              }
633          }          }
634        }        }
635      else      else
636        {        {
637        dlen = 0;         /* Not strictly necessary, but compilers moan */        dlen = 0;         /* Not strictly necessary, but compilers moan */
638        d = -1;           /* if these variables are not set. */        d = NOTACHAR;     /* if these variables are not set. */
639        }        }
640    
641    
# Line 574  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 588  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 624  for (;;) Line 705  for (;;)
705    
706        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
707        case OP_BRA:        case OP_BRA:
708          case OP_SBRA:
709        do        do
710          {          {
711          ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);          ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);
# Line 633  for (;;) Line 715  for (;;)
715        break;        break;
716    
717        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
718          case OP_CBRA:
719          case OP_SCBRA:
720          ADD_ACTIVE(code - start_code + 3 + LINK_SIZE,  0);
721          code += GET(code, 1);
722          while (*code == OP_ALT)
723            {
724            ADD_ACTIVE(code - start_code + 1 + LINK_SIZE,  0);
725            code += GET(code, 1);
726            }
727          break;
728    
729          /*-----------------------------------------------------------------*/
730        case OP_BRAZERO:        case OP_BRAZERO:
731        case OP_BRAMINZERO:        case OP_BRAMINZERO:
732        ADD_ACTIVE(state_offset + 1, 0);        ADD_ACTIVE(state_offset + 1, 0);
# Line 642  for (;;) Line 736  for (;;)
736        break;        break;
737    
738        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
739        case OP_BRANUMBER:        case OP_SKIPZERO:
740        ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0);        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;        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 &&
             ptr >= start_subject + md->nllen &&  
749              ptr != end_subject &&              ptr != end_subject &&
750              IS_NEWLINE(ptr - md->nllen)))              WAS_NEWLINE(ptr)))
751          { ADD_ACTIVE(state_offset + 1, 0); }          { ADD_ACTIVE(state_offset + 1, 0); }
752        break;        break;
753    
# Line 686  for (;;) Line 781  for (;;)
781    
782        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
783        case OP_ANY:        case OP_ANY:
784        if (clen > 0 && ((ims & PCRE_DOTALL) != 0 ||        if (clen > 0 && !IS_NEWLINE(ptr))
785                         ptr > end_subject - md->nllen ||          { ADD_NEW(state_offset + 1, 0); }
786                         !IS_NEWLINE(ptr)))        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    
794        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
795        case OP_EODN:        case OP_EODN:
796        if (clen == 0 ||        if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - md->nllen))
            (ptr == end_subject - md->nllen && IS_NEWLINE(ptr)))  
797          { ADD_ACTIVE(state_offset + 1, 0); }          { ADD_ACTIVE(state_offset + 1, 0); }
798        break;        break;
799    
# Line 704  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              (ptr <= end_subject - md->nllen && 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); }
809          }          }
810        else if ((ims & PCRE_MULTILINE) != 0 &&        else if ((ims & PCRE_MULTILINE) != 0 && IS_NEWLINE(ptr))
                ptr <= end_subject - md->nllen && IS_NEWLINE(ptr))  
811          { ADD_ACTIVE(state_offset + 1, 0); }          { ADD_ACTIVE(state_offset + 1, 0); }
812        break;        break;
813    
# Line 742  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 750  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 759  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 779  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 811  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:
921          case OP_TYPEPOSPLUS:
922        count = current_state->count;  /* Already matched */        count = current_state->count;  /* Already matched */
923        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
924        if (clen > 0)        if (clen > 0)
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 ||  
                ptr > end_subject - md->nllen ||  
                !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)
932                {
933                active_count--;            /* Remove non-match possibility */
934                next_active_state--;
935                }
936            count++;            count++;
937            ADD_NEW(state_offset, count);            ADD_NEW(state_offset, count);
938            }            }
# Line 838  for (;;) Line 942  for (;;)
942        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
943        case OP_TYPEQUERY:        case OP_TYPEQUERY:
944        case OP_TYPEMINQUERY:        case OP_TYPEMINQUERY:
945          case OP_TYPEPOSQUERY:
946        ADD_ACTIVE(state_offset + 2, 0);        ADD_ACTIVE(state_offset + 2, 0);
947        if (clen > 0)        if (clen > 0)
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 ||  
                ptr > end_subject - md->nllen ||  
                !IS_NEWLINE(ptr)  
               ) &&  
952                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
953            {            {
954              if (codevalue == OP_TYPEPOSQUERY)
955                {
956                active_count--;            /* Remove non-match possibility */
957                next_active_state--;
958                }
959            ADD_NEW(state_offset + 2, 0);            ADD_NEW(state_offset + 2, 0);
960            }            }
961          }          }
# Line 858  for (;;) Line 964  for (;;)
964        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
965        case OP_TYPESTAR:        case OP_TYPESTAR:
966        case OP_TYPEMINSTAR:        case OP_TYPEMINSTAR:
967          case OP_TYPEPOSSTAR:
968        ADD_ACTIVE(state_offset + 2, 0);        ADD_ACTIVE(state_offset + 2, 0);
969        if (clen > 0)        if (clen > 0)
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 ||  
                ptr > end_subject - md->nllen ||  
                !IS_NEWLINE(ptr)  
               ) &&  
974                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
975            {            {
976              if (codevalue == OP_TYPEPOSSTAR)
977                {
978                active_count--;            /* Remove non-match possibility */
979                next_active_state--;
980                }
981            ADD_NEW(state_offset, 0);            ADD_NEW(state_offset, 0);
982            }            }
983          }          }
# Line 877  for (;;) Line 985  for (;;)
985    
986        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
987        case OP_TYPEEXACT:        case OP_TYPEEXACT:
988          count = current_state->count;  /* Number already matched */
989          if (clen > 0)
990            {
991            if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
992                (c < 256 &&
993                  (d != OP_ANY || !IS_NEWLINE(ptr)) &&
994                  ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
995              {
996              if (++count >= GET2(code, 1))
997                { ADD_NEW(state_offset + 4, 0); }
998              else
999                { ADD_NEW(state_offset, count); }
1000              }
1001            }
1002          break;
1003    
1004          /*-----------------------------------------------------------------*/
1005        case OP_TYPEUPTO:        case OP_TYPEUPTO:
1006        case OP_TYPEMINUPTO:        case OP_TYPEMINUPTO:
1007        if (codevalue != OP_TYPEEXACT)        case OP_TYPEPOSUPTO:
1008          { ADD_ACTIVE(state_offset + 4, 0); }        ADD_ACTIVE(state_offset + 4, 0);
1009        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
1010        if (clen > 0)        if (clen > 0)
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 ||  
                ptr > end_subject - md->nllen ||  
                !IS_NEWLINE(ptr)  
               ) &&  
1015                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
1016            {            {
1017              if (codevalue == OP_TYPEPOSUPTO)
1018                {
1019                active_count--;           /* Remove non-match possibility */
1020                next_active_state--;
1021                }
1022            if (++count >= GET2(code, 1))            if (++count >= GET2(code, 1))
1023              { ADD_NEW(state_offset + 4, 0); }              { ADD_NEW(state_offset + 4, 0); }
1024            else            else
# Line 903  for (;;) Line 1029  for (;;)
1029    
1030  /* ========================================================================== */  /* ========================================================================== */
1031        /* These are virtual opcodes that are used when something like        /* These are virtual opcodes that are used when something like
1032        OP_TYPEPLUS has OP_PROP, OP_NOTPROP, or OP_EXTUNI as its argument. It        OP_TYPEPLUS has OP_PROP, OP_NOTPROP, OP_ANYNL, or OP_EXTUNI as its
1033        keeps the code above fast for the other cases. The argument is in the        argument. It keeps the code above fast for the other cases. The argument
1034        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:
1040        count = current_state->count;           /* Already matched */        count = current_state->count;           /* Already matched */
1041        if (count > 0) { ADD_ACTIVE(state_offset + 4, 0); }        if (count > 0) { ADD_ACTIVE(state_offset + 4, 0); }
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 922  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 944  for (;;) Line 1072  for (;;)
1072            break;            break;
1073            }            }
1074    
1075          if (OK == (d == OP_PROP)) { count++; ADD_NEW(state_offset, count); }          if (OK == (d == OP_PROP))
1076              {
1077              if (count > 0 && codevalue == OP_PROP_EXTRA + OP_TYPEPOSPLUS)
1078                {
1079                active_count--;           /* Remove non-match possibility */
1080                next_active_state--;
1081                }
1082              count++;
1083              ADD_NEW(state_offset, count);
1084              }
1085          }          }
1086        break;        break;
1087    
1088        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1089        case OP_EXTUNI_EXTRA + OP_TYPEPLUS:        case OP_EXTUNI_EXTRA + OP_TYPEPLUS:
1090        case OP_EXTUNI_EXTRA + OP_TYPEMINPLUS:        case OP_EXTUNI_EXTRA + OP_TYPEMINPLUS:
1091          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;
1098            if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS)
1099              {
1100              active_count--;           /* Remove non-match possibility */
1101              next_active_state--;
1102              }
1103          while (nptr < end_subject)          while (nptr < end_subject)
1104            {            {
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 970  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:
1120          case OP_ANYNL_EXTRA + OP_TYPEMINPLUS:
1121          case OP_ANYNL_EXTRA + OP_TYPEPOSPLUS:
1122          count = current_state->count;  /* Already matched */
1123          if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
1124          if (clen > 0)
1125            {
1126            int ncount = 0;
1127            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:
1138              if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1139              /* 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:
1170              case 0x000b:
1171              case 0x000c:
1172              case 0x000d:
1173              case 0x0085:
1174              case 0x2028:
1175              case 0x2029:
1176              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 */
1189                next_active_state--;
1190                }
1191              count++;
1192              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;
1229    
1230              default:
1231              OK = FALSE;
1232              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;
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:
1253        count = 4;        count = 4;
1254        goto QS1;        goto QS1;
1255    
1256        case OP_PROP_EXTRA + OP_TYPESTAR:        case OP_PROP_EXTRA + OP_TYPESTAR:
1257        case OP_PROP_EXTRA + OP_TYPEMINSTAR:        case OP_PROP_EXTRA + OP_TYPEMINSTAR:
1258          case OP_PROP_EXTRA + OP_TYPEPOSSTAR:
1259        count = 0;        count = 0;
1260    
1261        QS1:        QS1:
# Line 987  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 995  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 1017  for (;;) Line 1294  for (;;)
1294            break;            break;
1295            }            }
1296    
1297          if (OK == (d == OP_PROP)) { ADD_NEW(state_offset + count, 0); }          if (OK == (d == OP_PROP))
1298              {
1299              if (codevalue == OP_PROP_EXTRA + OP_TYPEPOSSTAR ||
1300                  codevalue == OP_PROP_EXTRA + OP_TYPEPOSQUERY)
1301                {
1302                active_count--;           /* Remove non-match possibility */
1303                next_active_state--;
1304                }
1305              ADD_NEW(state_offset + count, 0);
1306              }
1307          }          }
1308        break;        break;
1309    
1310        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1311        case OP_EXTUNI_EXTRA + OP_TYPEQUERY:        case OP_EXTUNI_EXTRA + OP_TYPEQUERY:
1312        case OP_EXTUNI_EXTRA + OP_TYPEMINQUERY:        case OP_EXTUNI_EXTRA + OP_TYPEMINQUERY:
1313          case OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY:
1314        count = 2;        count = 2;
1315        goto QS2;        goto QS2;
1316    
1317        case OP_EXTUNI_EXTRA + OP_TYPESTAR:        case OP_EXTUNI_EXTRA + OP_TYPESTAR:
1318        case OP_EXTUNI_EXTRA + OP_TYPEMINSTAR:        case OP_EXTUNI_EXTRA + OP_TYPEMINSTAR:
1319          case OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR:
1320        count = 0;        count = 0;
1321    
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;
1329            if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR ||
1330                codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY)
1331              {
1332              active_count--;           /* Remove non-match possibility */
1333              next_active_state--;
1334              }
1335          while (nptr < end_subject)          while (nptr < end_subject)
1336            {            {
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:
1351          case OP_ANYNL_EXTRA + OP_TYPEMINQUERY:
1352          case OP_ANYNL_EXTRA + OP_TYPEPOSQUERY:
1353          count = 2;
1354          goto QS3;
1355    
1356          case OP_ANYNL_EXTRA + OP_TYPESTAR:
1357          case OP_ANYNL_EXTRA + OP_TYPEMINSTAR:
1358          case OP_ANYNL_EXTRA + OP_TYPEPOSSTAR:
1359          count = 0;
1360    
1361          QS3:
1362          ADD_ACTIVE(state_offset + 2, 0);
1363          if (clen > 0)
1364            {
1365            int ncount = 0;
1366            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:
1377              if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1378              /* 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:
1417              case 0x000b:
1418              case 0x000c:
1419              case 0x000d:
1420              case 0x0085:
1421              case 0x2028:
1422              case 0x2029:
1423              OK = TRUE;
1424              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 */
1436                next_active_state--;
1437                }
1438              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;
1483    
1484              default:
1485              OK = FALSE;
1486              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;
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:
1507          case OP_PROP_EXTRA + OP_TYPEPOSUPTO:
1508        if (codevalue != OP_PROP_EXTRA + OP_TYPEEXACT)        if (codevalue != OP_PROP_EXTRA + OP_TYPEEXACT)
1509          { ADD_ACTIVE(state_offset + 6, 0); }          { ADD_ACTIVE(state_offset + 6, 0); }
1510        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
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 1069  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 1093  for (;;) Line 1543  for (;;)
1543    
1544          if (OK == (d == OP_PROP))          if (OK == (d == OP_PROP))
1545            {            {
1546              if (codevalue == OP_PROP_EXTRA + OP_TYPEPOSUPTO)
1547                {
1548                active_count--;           /* Remove non-match possibility */
1549                next_active_state--;
1550                }
1551            if (++count >= GET2(code, 1))            if (++count >= GET2(code, 1))
1552              { ADD_NEW(state_offset + 6, 0); }              { ADD_NEW(state_offset + 6, 0); }
1553            else            else
# Line 1105  for (;;) Line 1560  for (;;)
1560        case OP_EXTUNI_EXTRA + OP_TYPEEXACT:        case OP_EXTUNI_EXTRA + OP_TYPEEXACT:
1561        case OP_EXTUNI_EXTRA + OP_TYPEUPTO:        case OP_EXTUNI_EXTRA + OP_TYPEUPTO:
1562        case OP_EXTUNI_EXTRA + OP_TYPEMINUPTO:        case OP_EXTUNI_EXTRA + OP_TYPEMINUPTO:
1563          case OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO:
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;
1571            if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO)
1572              {
1573              active_count--;           /* Remove non-match possibility */
1574              next_active_state--;
1575              }
1576          while (nptr < end_subject)          while (nptr < end_subject)
1577            {            {
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 1127  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:
1595          case OP_ANYNL_EXTRA + OP_TYPEUPTO:
1596          case OP_ANYNL_EXTRA + OP_TYPEMINUPTO:
1597          case OP_ANYNL_EXTRA + OP_TYPEPOSUPTO:
1598          if (codevalue != OP_ANYNL_EXTRA + OP_TYPEEXACT)
1599            { ADD_ACTIVE(state_offset + 4, 0); }
1600          count = current_state->count;  /* Number already matched */
1601          if (clen > 0)
1602            {
1603            int ncount = 0;
1604            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:
1615              if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
1616              /* 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:
1651              case 0x000b:
1652              case 0x000c:
1653              case 0x000d:
1654              case 0x0085:
1655              case 0x2028:
1656              case 0x2029:
1657              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 */
1669                next_active_state--;
1670                }
1671              if (++count >= GET2(code, 1))
1672                { ADD_NEW_DATA(-(state_offset + 4), 0, 0); }
1673              else
1674                { 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;
1713    
1714              default:
1715              OK = FALSE;
1716              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;
1733    
1734  /* ========================================================================== */  /* ========================================================================== */
1735        /* These opcodes are followed by a character that is usually compared        /* These opcodes are followed by a character that is usually compared
# Line 1148  for (;;) Line 1751  for (;;)
1751          {          {
1752          if (c == d) { ADD_NEW(state_offset + dlen + 1, 0); } else          if (c == d) { ADD_NEW(state_offset + dlen + 1, 0); } else
1753            {            {
1754            int othercase;            unsigned int othercase;
1755            if (c < 128) othercase = fcc[c]; else            if (c < 128) othercase = fcc[c]; else
1756    
1757            /* If we have Unicode property support, we can use it to test the            /* If we have Unicode property support, we can use it to test the
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 = -1;            othercase = NOTACHAR;
1764  #endif  #endif
1765    
1766            if (d == othercase) { ADD_NEW(state_offset + dlen + 1, 0); }            if (d == othercase) { ADD_NEW(state_offset + dlen + 1, 0); }
# Line 1180  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 1188  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 1198  for (;;) Line 1801  for (;;)
1801  #endif  #endif
1802    
1803        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1804          /* This is a tricky like EXTUNI because it too can match more than one
1805          character (when CR is followed by LF). In this case, set up a negative
1806          state to wait for one character to pass before continuing. */
1807    
1808          case OP_ANYNL:
1809          if (clen > 0) switch(c)
1810            {
1811            case 0x000b:
1812            case 0x000c:
1813            case 0x0085:
1814            case 0x2028:
1815            case 0x2029:
1816            if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
1817    
1818            case 0x000a:
1819            ADD_NEW(state_offset + 1, 0);
1820            break;
1821    
1822            case 0x000d:
1823            if (ptr + 1 < end_subject && ptr[1] == 0x0a)
1824              {
1825              ADD_NEW_DATA(-(state_offset + 1), 0, 1);
1826              }
1827            else
1828              {
1829              ADD_NEW(state_offset + 1, 0);
1830              }
1831            break;
1832            }
1833          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 1205  for (;;) Line 1936  for (;;)
1936        case OP_NOT:        case OP_NOT:
1937        if (clen > 0)        if (clen > 0)
1938          {          {
1939          int otherd = ((ims & PCRE_CASELESS) != 0)? fcc[d] : d;          unsigned int otherd = ((ims & PCRE_CASELESS) != 0)? fcc[d] : d;
1940          if (c != d && c != otherd) { ADD_NEW(state_offset + dlen + 1, 0); }          if (c != d && c != otherd) { ADD_NEW(state_offset + dlen + 1, 0); }
1941          }          }
1942        break;        break;
# Line 1213  for (;;) Line 1944  for (;;)
1944        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1945        case OP_PLUS:        case OP_PLUS:
1946        case OP_MINPLUS:        case OP_MINPLUS:
1947          case OP_POSPLUS:
1948        case OP_NOTPLUS:        case OP_NOTPLUS:
1949        case OP_NOTMINPLUS:        case OP_NOTMINPLUS:
1950          case OP_NOTPOSPLUS:
1951        count = current_state->count;  /* Already matched */        count = current_state->count;  /* Already matched */
1952        if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); }        if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); }
1953        if (clen > 0)        if (clen > 0)
1954          {          {
1955          int otherd = -1;          unsigned int otherd = NOTACHAR;
1956          if ((ims & PCRE_CASELESS) != 0)          if ((ims & PCRE_CASELESS) != 0)
1957            {            {
1958  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
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 1234  for (;;) Line 1967  for (;;)
1967            otherd = fcc[d];            otherd = fcc[d];
1968            }            }
1969          if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))          if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
1970            { count++; ADD_NEW(state_offset, count); }            {
1971              if (count > 0 &&
1972                  (codevalue == OP_POSPLUS || codevalue == OP_NOTPOSPLUS))
1973                {
1974                active_count--;             /* Remove non-match possibility */
1975                next_active_state--;
1976                }
1977              count++;
1978              ADD_NEW(state_offset, count);
1979              }
1980          }          }
1981        break;        break;
1982    
1983        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
1984        case OP_QUERY:        case OP_QUERY:
1985        case OP_MINQUERY:        case OP_MINQUERY:
1986          case OP_POSQUERY:
1987        case OP_NOTQUERY:        case OP_NOTQUERY:
1988        case OP_NOTMINQUERY:        case OP_NOTMINQUERY:
1989          case OP_NOTPOSQUERY:
1990        ADD_ACTIVE(state_offset + dlen + 1, 0);        ADD_ACTIVE(state_offset + dlen + 1, 0);
1991        if (clen > 0)        if (clen > 0)
1992          {          {
1993          int otherd = -1;          unsigned int otherd = NOTACHAR;
1994          if ((ims & PCRE_CASELESS) != 0)          if ((ims & PCRE_CASELESS) != 0)
1995            {            {
1996  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
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 1261  for (;;) Line 2005  for (;;)
2005            otherd = fcc[d];            otherd = fcc[d];
2006            }            }
2007          if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))          if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
2008            { ADD_NEW(state_offset + dlen + 1, 0); }            {
2009              if (codevalue == OP_POSQUERY || codevalue == OP_NOTPOSQUERY)
2010                {
2011                active_count--;            /* Remove non-match possibility */
2012                next_active_state--;
2013                }
2014              ADD_NEW(state_offset + dlen + 1, 0);
2015              }
2016          }          }
2017        break;        break;
2018    
2019        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2020        case OP_STAR:        case OP_STAR:
2021        case OP_MINSTAR:        case OP_MINSTAR:
2022          case OP_POSSTAR:
2023        case OP_NOTSTAR:        case OP_NOTSTAR:
2024        case OP_NOTMINSTAR:        case OP_NOTMINSTAR:
2025          case OP_NOTPOSSTAR:
2026        ADD_ACTIVE(state_offset + dlen + 1, 0);        ADD_ACTIVE(state_offset + dlen + 1, 0);
2027        if (clen > 0)        if (clen > 0)
2028          {          {
2029          int otherd = -1;          unsigned int otherd = NOTACHAR;
2030          if ((ims & PCRE_CASELESS) != 0)          if ((ims & PCRE_CASELESS) != 0)
2031            {            {
2032  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
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 1288  for (;;) Line 2041  for (;;)
2041            otherd = fcc[d];            otherd = fcc[d];
2042            }            }
2043          if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))          if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
2044            { ADD_NEW(state_offset, 0); }            {
2045              if (codevalue == OP_POSSTAR || codevalue == OP_NOTPOSSTAR)
2046                {
2047                active_count--;            /* Remove non-match possibility */
2048                next_active_state--;
2049                }
2050              ADD_NEW(state_offset, 0);
2051              }
2052          }          }
2053        break;        break;
2054    
2055        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2056        case OP_EXACT:        case OP_EXACT:
2057          case OP_NOTEXACT:
2058          count = current_state->count;  /* Number already matched */
2059          if (clen > 0)
2060            {
2061            unsigned int otherd = NOTACHAR;
2062            if ((ims & PCRE_CASELESS) != 0)
2063              {
2064    #ifdef SUPPORT_UTF8
2065              if (utf8 && d >= 128)
2066                {
2067    #ifdef SUPPORT_UCP
2068                otherd = UCD_OTHERCASE(d);
2069    #endif  /* SUPPORT_UCP */
2070                }
2071              else
2072    #endif  /* SUPPORT_UTF8 */
2073              otherd = fcc[d];
2074              }
2075            if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
2076              {
2077              if (++count >= GET2(code, 1))
2078                { ADD_NEW(state_offset + dlen + 3, 0); }
2079              else
2080                { ADD_NEW(state_offset, count); }
2081              }
2082            }
2083          break;
2084    
2085          /*-----------------------------------------------------------------*/
2086        case OP_UPTO:        case OP_UPTO:
2087        case OP_MINUPTO:        case OP_MINUPTO:
2088        case OP_NOTEXACT:        case OP_POSUPTO:
2089        case OP_NOTUPTO:        case OP_NOTUPTO:
2090        case OP_NOTMINUPTO:        case OP_NOTMINUPTO:
2091        if (codevalue != OP_EXACT && codevalue != OP_NOTEXACT)        case OP_NOTPOSUPTO:
2092          { ADD_ACTIVE(state_offset + dlen + 3, 0); }        ADD_ACTIVE(state_offset + dlen + 3, 0);
2093        count = current_state->count;  /* Number already matched */        count = current_state->count;  /* Number already matched */
2094        if (clen > 0)        if (clen > 0)
2095          {          {
2096          int otherd = -1;          unsigned int otherd = NOTACHAR;
2097          if ((ims & PCRE_CASELESS) != 0)          if ((ims & PCRE_CASELESS) != 0)
2098            {            {
2099  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
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 1320  for (;;) Line 2109  for (;;)
2109            }            }
2110          if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))          if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
2111            {            {
2112              if (codevalue == OP_POSUPTO || codevalue == OP_NOTPOSUPTO)
2113                {
2114                active_count--;             /* Remove non-match possibility */
2115                next_active_state--;
2116                }
2117            if (++count >= GET2(code, 1))            if (++count >= GET2(code, 1))
2118              { ADD_NEW(state_offset + dlen + 3, 0); }              { ADD_NEW(state_offset + dlen + 3, 0); }
2119            else            else
# Line 1414  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 1448  for (;;) Line 2248  for (;;)
2248    
2249        /*-----------------------------------------------------------------*/        /*-----------------------------------------------------------------*/
2250        case OP_COND:        case OP_COND:
2251          case OP_SCOND:
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          /* The only supported version of OP_CREF is for the value 0xffff, which          /* Because of the way auto-callout works during compile, a callout item
2259          means "test if in a recursion". */          is inserted between OP_COND and an assertion condition. This does not
2260            happen for the other conditions. */
2261    
2262          if (condcode == OP_CREF)          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 */
2289    
2290            if (condcode == OP_CREF) return PCRE_ERROR_DFA_UCOND;
2291    
2292            /* The DEFINE condition is always false */
2293    
2294            if (condcode == OP_DEF)
2295              { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
2296    
2297            /* 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
2299            recursed groups. */
2300    
2301            else if (condcode == OP_RREF)
2302            {            {
2303            int value = GET2(code, LINK_SIZE+2);            int value = GET2(code, LINK_SIZE+2);
2304            if (value != 0xffff) 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 1491  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 1643  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 1660  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 1677  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 1728  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 1744  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 1831  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_CRLF) == 0)? re->options : options) &  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &
2708           PCRE_NEWLINE_CRLF)           PCRE_NEWLINE_BITS)
2709    {    {
2710    default:              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;
2716      case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
2717      default: return PCRE_ERROR_BADNEWLINE;
2718    }    }
2719    
2720  if (newline > 255)  if (newline == -2)
2721    {    {
2722    md->nllen = 2;    md->nltype = NLTYPE_ANYCRLF;
2723    md->nl[0] = (newline >> 8) & 255;    }
2724    md->nl[1] = newline & 255;  else if (newline < 0)
2725      {
2726      md->nltype = NLTYPE_ANY;
2727    }    }
2728  else  else
2729    {    {
2730    md->nllen = 1;    md->nltype = NLTYPE_FIXED;
2731    md->nl[0] = newline;    if (newline > 255)
2732        {
2733        md->nllen = 2;
2734        md->nl[0] = (newline >> 8) & 255;
2735        md->nl[1] = newline & 255;
2736        }
2737      else
2738        {
2739        md->nllen = 1;
2740        md->nl[0] = newline;
2741        }
2742    }    }
2743    
2744  /* Check a UTF-8 string if required. Unfortunately there's no way of passing  /* Check a UTF-8 string if required. Unfortunately there's no way of passing
# Line 1889  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 1900  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 1917  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 1925  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 1937  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        while (t <= save_end_subject - md->nllen && !IS_NEWLINE(t)) t++;  #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++;
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 + md->nllen +  
           start_offset)  
2855          {          {
2856          while (current_subject <= end_subject &&          if (first_byte_caseless)
2857                 !IS_NEWLINE(current_subject - md->nllen))            while (current_subject < end_subject &&
2858            current_subject++;                   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 2004  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 2049  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 2070  for (;;) Line 3000  for (;;)
3000    /* Advance to the next subject character unless we are at the end of a line    /* Advance to the next subject character unless we are at the end of a line
3001    and firstline is set. */    and firstline is set. */
3002    
3003    if (firstline &&    if (firstline && IS_NEWLINE(current_subject)) break;
       current_subject <= end_subject - md->nllen &&  
       IS_NEWLINE(current_subject)) break;  
3004    current_subject++;    current_subject++;
3005    if (utf8)    if (utf8)
3006      {      {
# Line 2080  for (;;) Line 3008  for (;;)
3008        current_subject++;        current_subject++;
3009      }      }
3010    if (current_subject > end_subject) break;    if (current_subject > end_subject) break;
3011    }  
3012      /* If we have just passed a CR and we are now at a LF, and the pattern does
3013      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    
3016      if (current_subject[-1] == CHAR_CR &&
3017          current_subject < end_subject &&
3018          *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++;
3024    
3025      }   /* "Bumpalong" loop */
3026    
3027  return PCRE_ERROR_NOMATCH;  return PCRE_ERROR_NOMATCH;
3028  }  }

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

  ViewVC Help
Powered by ViewVC 1.1.5