/[pcre]/code/branches/pcre16/pcre_dfa_exec.c

Diff of /code/branches/pcre16/pcre_dfa_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 178 by ph10,
Wed Jun 13 08:44:34 2007 UTC
+revision 579 by ph10,
Wed Nov 24 17:39:25 2010 UTC
 Line 3
  *************************************************/
  /* PCRE is a library of functions to support regular expressions whose syntax
- 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
+ below for why this module is different).
                         Written by Philip Hazel
-            Copyright (c) 1997-2007 University of Cambridge
+            Copyright (c) 1997-2010 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
-Line 44 
 FSM). This is NOT Perl- compatible, but
+Line 45 
 FSM). This is NOT Perl- compatible, but
  applications. */
+ /* NOTE ABOUT PERFORMANCE: A user of this function sent some code that improved
+ the performance of his patterns greatly. I could not use it as it stood, as it
+ was not thread safe, and made assumptions about pattern sizes. Also, it caused
+ test 7 to loop, and test 9 to crash with a segfault.
+ The issue is the check for duplicate states, which is done by a simple linear
+ search up the state list. (Grep for "duplicate" below to find the code.) For
+ many patterns, there will never be many states active at one time, so a simple
+ linear search is fine. In patterns that have many active states, it might be a
+ bottleneck. The suggested code used an indexing scheme to remember which states
+ had previously been used for each character, and avoided the linear search when
+ it knew there was no chance of a duplicate. This was implemented when adding
+ states to the state lists.
+ I wrote some thread-safe, not-limited code to try something similar at the time
+ of checking for duplicates (instead of when adding states), using index vectors
+ on the stack. It did give a 13% improvement with one specially constructed
+ pattern for certain subject strings, but on other strings and on many of the
+ simpler patterns in the test suite it did worse. The major problem, I think,
+ was the extra time to initialize the index. This had to be done for each call
+ of internal_dfa_exec(). (The supplied patch used a static vector, initialized
+ only once - I suspect this was the cause of the problems with the tests.)
+ Overall, I concluded that the gains in some cases did not outweigh the losses
+ in others, so I abandoned this code. */
+ #ifdef HAVE_CONFIG_H
+ #include "config.h"
+ #endif
  #define NLBLOCK md             /* Block containing newline information */
  #define PSSTART start_subject  /* Field containing processed string start */
  #define PSEND   end_subject    /* Field containing processed string end */
-Line 56 
 applications. */
+Line 89 
 applications. */
  #define SP "                   "
  /*************************************************
  *      Code parameters and static tables         *
  *************************************************/
  /* These are offsets that are used to turn the OP_TYPESTAR and friends opcodes
  into others, under special conditions. A gap of 20 between the blocks should be
  enough. The resulting opcodes don't have to be less than 256 because they are
  never stored, so we push them well clear of the normal opcodes. */
  #define OP_PROP_EXTRA       300
-Line 74 
 never stored, so we push them well clear
+Line 106 
 never stored, so we push them well clear
  /* This table identifies those opcodes that are followed immediately by a
- character that is to be tested in some way. This makes is possible to
+ character that is to be tested in some way. This makes it possible to
  centralize the loading of these characters. In the case of Type * etc, the
  "character" is the opcode for \D, \d, \S, \s, \W, or \w, which will always be a
- small value. ***NOTE*** If the start of this table is modified, the two tables
+ small value. Non-zero values in the table are the offsets from the opcode where
- that follow must also be modified. */
+ the character is to be found. ***NOTE*** If the start of this table is
+ modified, the three tables that follow must also be modified. */
- static uschar coptable[] = {
+ static const uschar coptable[] = {
 ,                             /* End                                    */
 , 0, 0, 0, 0,                 /* \A, \G, \K, \B, \b                     */
 , 0, 0, 0, 0, 0,              /* \D, \d, \S, \s, \W, \w                 */
-, 0,                          /* Any, Anybyte                           */
+, 0, 0,                       /* Any, AllAny, Anybyte                   */
-, 0, 0,                       /* NOTPROP, PROP, EXTUNI                  */
+, 0,                          /* \P, \p                                 */
 , 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */
+,                             /* \X                                     */
 , 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */
 ,                             /* Char                                   */
 ,                             /* Charnc                                 */
-Line 123 
 static uschar coptable[] = {
+Line 157 
 static uschar coptable[] = {
 ,                             /* Reverse                                */
 , 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */
 , 0, 0,                       /* SBRA, SCBRA, SCOND                     */
-,                             /* CREF                                   */
+, 0,                          /* CREF, NCREF                            */
-,                             /* RREF                                   */
+, 0,                          /* RREF, NRREF                            */
+,                             /* DEF                                    */
+, 0,                          /* BRAZERO, BRAMINZERO                    */
+, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */
+, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG,        */
+, 0, 0, 0, 0                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */
+ };
+ /* This table identifies those opcodes that inspect a character. It is used to
+ remember the fact that a character could have been inspected when the end of
+ the subject is reached. ***NOTE*** If the start of this table is modified, the
+ two tables that follow must also be modified. */
+ static const uschar poptable[] = {
+,                             /* End                                    */
+, 0, 0, 1, 1,                 /* \A, \G, \K, \B, \b                     */
+, 1, 1, 1, 1, 1,              /* \D, \d, \S, \s, \W, \w                 */
+, 1, 1,                       /* Any, AllAny, Anybyte                   */
+, 1,                          /* \P, \p                                 */
+, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */
+,                             /* \X                                     */
+, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */
+,                             /* Char                                   */
+,                             /* Charnc                                 */
+,                             /* not                                    */
+   /* Positive single-char repeats                                          */
+, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
+, 1, 1,                       /* upto, minupto, exact                   */
+, 1, 1, 1,                    /* *+, ++, ?+, upto+                      */
+   /* Negative single-char repeats - only for chars < 256                   */
+, 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */
+, 1, 1,                       /* NOT upto, minupto, exact               */
+, 1, 1, 1,                    /* NOT *+, ++, ?+, upto+                  */
+   /* Positive type repeats                                                 */
+, 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */
+, 1, 1,                       /* Type upto, minupto, exact              */
+, 1, 1, 1,                    /* Type *+, ++, ?+, upto+                 */
+   /* Character class & ref repeats                                         */
+, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
+, 1,                          /* CRRANGE, CRMINRANGE                    */
+,                             /* CLASS                                  */
+,                             /* NCLASS                                 */
+,                             /* XCLASS - variable length               */
+,                             /* REF                                    */
+,                             /* RECURSE                                */
+,                             /* CALLOUT                                */
+,                             /* Alt                                    */
+,                             /* Ket                                    */
+,                             /* KetRmax                                */
+,                             /* KetRmin                                */
+,                             /* Assert                                 */
+,                             /* Assert not                             */
+,                             /* Assert behind                          */
+,                             /* Assert behind not                      */
+,                             /* Reverse                                */
+, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */
+, 0, 0,                       /* SBRA, SCBRA, SCOND                     */
+, 0,                          /* CREF, NCREF                            */
+, 0,                          /* RREF, NRREF                            */
 ,                             /* DEF                                    */
-, 0                           /* BRAZERO, BRAMINZERO                    */
+, 0,                          /* BRAZERO, BRAMINZERO                    */
+, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */
+, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG,        */
+, 0, 0, 0, 0                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */
  };
  /* These 2 tables allow for compact code for testing for \D, \d, \S, \s, \W,
  and \w */
- static uschar toptable1[] = {
+ static const uschar toptable1[] = {
 , 0, 0, 0, 0, 0,
    ctype_digit, ctype_digit,
    ctype_space, ctype_space,
    ctype_word,  ctype_word,
-                              /* OP_ANY */
+, 0                            /* OP_ANY, OP_ALLANY */
  };
- static uschar toptable2[] = {
+ static const uschar toptable2[] = {
 , 0, 0, 0, 0, 0,
    ctype_digit, 0,
    ctype_space, 0,
    ctype_word,  0,
-                              /* OP_ANY */
+, 1                            /* OP_ANY, OP_ALLANY */
  };
-Line 164 
 typedef struct stateblock {
+Line 259 
 typedef struct stateblock {
  #define INTS_PER_STATEBLOCK  (sizeof(stateblock)/sizeof(int))
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  /*************************************************
  *             Print character string             *
  *************************************************/
-Line 217 
 Arguments:
+Line 312 
 Arguments:
    rlevel            function call recursion level
    recursing         regex recursive call level
- Returns:            > 0 =>
+ Returns:            > 0 => number of match offset pairs placed in offsets
-                     = 0 =>
+                     = 0 => offsets overflowed; longest matches are present
                       -1 => failed to match
                     < -1 => some kind of unexpected problem
-Line 380 
 if (*first_op == OP_REVERSE)
+Line 475 
 if (*first_op == OP_REVERSE)
      {
      gone_back = (current_subject - max_back < start_subject)?
-       current_subject - start_subject : max_back;
+       (int)(current_subject - start_subject) : max_back;
      current_subject -= gone_back;
      }
+   /* Save the earliest consulted character */
+   if (current_subject < md->start_used_ptr)
+     md->start_used_ptr = current_subject;
    /* Now we can process the individual branches. */
    end_code = this_start_code;
-Line 392 
 if (*first_op == OP_REVERSE)
+Line 492 
 if (*first_op == OP_REVERSE)
      int back = GET(end_code, 2+LINK_SIZE);
      if (back <= gone_back)
        {
-       int bstate = end_code - start_code + 2 + 2*LINK_SIZE;
+       int bstate = (int)(end_code - start_code + 2 + 2*LINK_SIZE);
        ADD_NEW_DATA(-bstate, 0, gone_back - back);
        }
      end_code += GET(end_code, 1);
-Line 428 
 else
+Line 528 
 else
        ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);
      do
        {
-       ADD_NEW(end_code - start_code + length, 0);
+       ADD_NEW((int)(end_code - start_code + length), 0);
        end_code += GET(end_code, 1);
        length = 1 + LINK_SIZE;
        }
-Line 448 
 for (;;)
+Line 548 
 for (;;)
    int i, j;
    int clen, dlen;
    unsigned int c, d;
+   int forced_fail = 0;
+   BOOL could_continue = FALSE;
    /* Make the new state list into the active state list and empty the
    new state list. */
-Line 461 
 for (;;)
+Line 563 
 for (;;)
    workspace[0] ^= 1;              /* Remember for the restarting feature */
    workspace[1] = active_count;
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
    printf("%.*sNext character: rest of subject = \"", rlevel*2-2, SP);
    pchars((uschar *)ptr, strlen((char *)ptr), stdout);
    printf("\"\n");
-Line 505 
 for (;;)
+Line 607 
 for (;;)
      stateblock *current_state = active_states + i;
      const uschar *code;
      int state_offset = current_state->offset;
-     int count, codevalue;
+     int count, codevalue, rrc;
- #ifdef SUPPORT_UCP
-     int chartype, script;
- #endif
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
      printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);
      if (clen == 0) printf("EOL\n");
        else if (c > 32 && c < 127) printf("'%c'\n", c);
-Line 540 
 for (;;)
+Line 639 
 for (;;)
          }
        }
-     /* 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.
+     See the note at the head of this module about the possibility of improving
+     performance here. */
      for (j = 0; j < i; j++)
        {
-Line 557 
 for (;;)
+Line 658 
 for (;;)
      code = start_code + state_offset;
      codevalue = *code;
+     /* If this opcode inspects a character, but we are at the end of the
+     subject, remember the fact for use when testing for a partial match. */
+     if (clen == 0 && poptable[codevalue] != 0)
+       could_continue = TRUE;
      /* If this opcode is followed by an inline character, load it. It is
      tempting to test for the presence of a subject character here, but that
      is wrong, because sometimes zero repetitions of the subject are
-Line 585 
 for (;;)
+Line 692 
 for (;;)
            case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break;
            case OP_EXTUNI: codevalue += OP_EXTUNI_EXTRA; break;
            case OP_NOT_HSPACE:
            case OP_HSPACE: codevalue += OP_HSPACE_EXTRA; break;
            case OP_NOT_VSPACE:
            case OP_VSPACE: codevalue += OP_VSPACE_EXTRA; break;
            default: break;
            }
          }
-Line 603 
 for (;;)
+Line 710 
 for (;;)
      switch (codevalue)
        {
+ /* ========================================================================== */
+       /* These cases are never obeyed. This is a fudge that causes a compile-
+       time error if the vectors coptable or poptable, which are indexed by
+       opcode, are not the correct length. It seems to be the only way to do
+       such a check at compile time, as the sizeof() operator does not work
+       in the C preprocessor. */
+       case OP_TABLE_LENGTH:
+       case OP_TABLE_LENGTH +
+         ((sizeof(coptable) == OP_TABLE_LENGTH) &&
+          (sizeof(poptable) == OP_TABLE_LENGTH)):
+       break;
  /* ========================================================================== */
        /* Reached a closing bracket. If not at the end of the pattern, carry
        on with the next opcode. Otherwise, unless we have an empty string and
-       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
+       start of the subject, save the match data, shifting up all previous
        matches so we always have the longest first. */
        case OP_KET:
-Line 621 
 for (;;)
+Line 741 
 for (;;)
            ADD_ACTIVE(state_offset - GET(code, 1), 0);
            }
          }
-       else if (ptr > current_subject || (md->moptions & PCRE_NOTEMPTY) == 0)
+       else
          {
-         if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;
+         if (ptr > current_subject ||
-           else if (match_count > 0 && ++match_count * 2 >= offsetcount)
+             ((md->moptions & PCRE_NOTEMPTY) == 0 &&
-             match_count = 0;
+               ((md->moptions & PCRE_NOTEMPTY_ATSTART) == 0 ||
-         count = ((match_count == 0)? offsetcount : match_count * 2) - 2;
+                 current_subject > start_subject + md->start_offset)))
-         if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));
+           {
-         if (offsetcount >= 2)
+           if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;
-           {
+             else if (match_count > 0 && ++match_count * 2 >= offsetcount)
-           offsets[0] = current_subject - start_subject;
+               match_count = 0;
-           offsets[1] = ptr - start_subject;
+           count = ((match_count == 0)? offsetcount : match_count * 2) - 2;
-           DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,
+           if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));
-             offsets[1] - offsets[0], current_subject));
+           if (offsetcount >= 2)
-           }
+             {
-         if ((md->moptions & PCRE_DFA_SHORTEST) != 0)
+             offsets[0] = (int)(current_subject - start_subject);
-           {
+             offsets[1] = (int)(ptr - start_subject);
-           DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"
+             DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,
-             "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel,
+               offsets[1] - offsets[0], current_subject));
-             match_count, rlevel*2-2, SP));
+             }
-           return match_count;
+           if ((md->moptions & PCRE_DFA_SHORTEST) != 0)
+             {
+             DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"
+               "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel,
+               match_count, rlevel*2-2, SP));
+             return match_count;
+             }
            }
          }
        break;
-Line 652 
 for (;;)
+Line 778 
 for (;;)
        /*-----------------------------------------------------------------*/
        case OP_ALT:
        do { code += GET(code, 1); } while (*code == OP_ALT);
-       ADD_ACTIVE(code - start_code, 0);
+       ADD_ACTIVE((int)(code - start_code), 0);
        break;
        /*-----------------------------------------------------------------*/
-Line 660 
 for (;;)
+Line 786 
 for (;;)
        case OP_SBRA:
        do
          {
-         ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);
+         ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
          code += GET(code, 1);
          }
        while (*code == OP_ALT);
-Line 669 
 for (;;)
+Line 795 
 for (;;)
        /*-----------------------------------------------------------------*/
        case OP_CBRA:
        case OP_SCBRA:
-       ADD_ACTIVE(code - start_code + 3 + LINK_SIZE,  0);
+       ADD_ACTIVE((int)(code - start_code + 3 + LINK_SIZE),  0);
        code += GET(code, 1);
        while (*code == OP_ALT)
          {
-         ADD_ACTIVE(code - start_code + 1 + LINK_SIZE,  0);
+         ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE),  0);
          code += GET(code, 1);
          }
        break;
-Line 684 
 for (;;)
+Line 810 
 for (;;)
        ADD_ACTIVE(state_offset + 1, 0);
        code += 1 + GET(code, 2);
        while (*code == OP_ALT) code += GET(code, 1);
-       ADD_ACTIVE(code - start_code + 1 + LINK_SIZE, 0);
+       ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_SKIPZERO:
+       code += 1 + GET(code, 2);
+       while (*code == OP_ALT) code += GET(code, 1);
+       ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
        break;
        /*-----------------------------------------------------------------*/
-Line 698 
 for (;;)
+Line 831 
 for (;;)
        /*-----------------------------------------------------------------*/
        case OP_EOD:
-       if (ptr >= end_subject) { ADD_ACTIVE(state_offset + 1, 0); }
+       if (ptr >= end_subject)
+         {
+         if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
+           could_continue = TRUE;
+         else { ADD_ACTIVE(state_offset + 1, 0); }
+         }
        break;
        /*-----------------------------------------------------------------*/
-Line 726 
 for (;;)
+Line 864 
 for (;;)
        /*-----------------------------------------------------------------*/
        case OP_ANY:
-       if (clen > 0 && ((ims & PCRE_DOTALL) != 0 || !IS_NEWLINE(ptr)))
+       if (clen > 0 && !IS_NEWLINE(ptr))
+         { ADD_NEW(state_offset + 1, 0); }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_ALLANY:
+       if (clen > 0)
          { ADD_NEW(state_offset + 1, 0); }
        break;
        /*-----------------------------------------------------------------*/
        case OP_EODN:
-       if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - md->nllen))
+       if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
+         could_continue = TRUE;
+       else if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - md->nllen))
          { ADD_ACTIVE(state_offset + 1, 0); }
        break;
-Line 740 
 for (;;)
+Line 886 
 for (;;)
        case OP_DOLL:
        if ((md->moptions & PCRE_NOTEOL) == 0)
          {
-         if (clen == 0 ||
+         if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
-             (IS_NEWLINE(ptr) &&
+           could_continue = TRUE;
+         else if (clen == 0 ||
+             ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&
                 ((ims & PCRE_MULTILINE) != 0 || ptr == end_subject - md->nllen)
              ))
            { ADD_ACTIVE(state_offset + 1, 0); }
-Line 778 
 for (;;)
+Line 926 
 for (;;)
          if (ptr > start_subject)
            {
            const uschar *temp = ptr - 1;
+           if (temp < md->start_used_ptr) md->start_used_ptr = temp;
  #ifdef SUPPORT_UTF8
            if (utf8) BACKCHAR(temp);
  #endif
            GETCHARTEST(d, temp);
+ #ifdef SUPPORT_UCP
+           if ((md->poptions & PCRE_UCP) != 0)
+             {
+             if (d == '_') left_word = TRUE; else
+               {
+               int cat = UCD_CATEGORY(d);
+               left_word = (cat == ucp_L || cat == ucp_N);
+               }
+             }
+           else
+ #endif
            left_word = d < 256 && (ctypes[d] & ctype_word) != 0;
            }
-         else left_word = 0;
+         else left_word = FALSE;
-         if (clen > 0) right_word = c < 256 && (ctypes[c] & ctype_word) != 0;
+         if (clen > 0)
-           else right_word = 0;
+           {
+ #ifdef SUPPORT_UCP
+           if ((md->poptions & PCRE_UCP) != 0)
+             {
+             if (c == '_') right_word = TRUE; else
+               {
+               int cat = UCD_CATEGORY(c);
+               right_word = (cat == ucp_L || cat == ucp_N);
+               }
+             }
+           else
+ #endif
+           right_word = c < 256 && (ctypes[c] & ctype_word) != 0;
+           }
+         else right_word = FALSE;
          if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY))
            { ADD_ACTIVE(state_offset + 1, 0); }
-Line 806 
 for (;;)
+Line 980 
 for (;;)
        if (clen > 0)
          {
          BOOL OK;
-         int category = _pcre_ucp_findprop(c, &chartype, &script);
+         const ucd_record * prop = GET_UCD(c);
          switch(code[1])
            {
            case PT_ANY:
-Line 814 
 for (;;)
+Line 988 
 for (;;)
            break;
            case PT_LAMP:
-           OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;
+           OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
+                prop->chartype == ucp_Lt;
            break;
            case PT_GC:
-           OK = category == code[2];
+           OK = _pcre_ucp_gentype[prop->chartype] == code[2];
            break;
            case PT_PC:
-           OK = chartype == code[2];
+           OK = prop->chartype == code[2];
            break;
            case PT_SC:
-           OK = script == code[2];
+           OK = prop->script == code[2];
+           break;
+           /* These are specials for combination cases. */
+           case PT_ALNUM:
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
+                _pcre_ucp_gentype[prop->chartype] == ucp_N;
+           break;
+           case PT_SPACE:    /* Perl space */
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+                c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
+           break;
+           case PT_PXSPACE:  /* POSIX space */
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+                c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
+                c == CHAR_FF || c == CHAR_CR;
+           break;
+           case PT_WORD:
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
+                _pcre_ucp_gentype[prop->chartype] == ucp_N ||
+                c == CHAR_UNDERSCORE;
            break;
            /* Should never occur, but keep compilers from grumbling. */
-Line 846 
 for (;;)
+Line 1045 
 for (;;)
  /* ========================================================================== */
        /* These opcodes likewise inspect the subject character, but have an
        argument that is not a data character. It is one of these opcodes:
-       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,
-       OP_NOT_WORDCHAR. The value is loaded into d. */
+       OP_WORDCHAR, OP_NOT_WORDCHAR. The value is loaded into d. */
        case OP_TYPEPLUS:
        case OP_TYPEMINPLUS:
-Line 858 
 for (;;)
+Line 1057 
 for (;;)
          {
          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
              (c < 256 &&
-               (d != OP_ANY ||
+               (d != OP_ANY || !IS_NEWLINE(ptr)) &&
-                (ims & PCRE_DOTALL) != 0 ||
-                !IS_NEWLINE(ptr)
-               ) &&
                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
            {
            if (count > 0 && codevalue == OP_TYPEPOSPLUS)
-Line 884 
 for (;;)
+Line 1080 
 for (;;)
          {
          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
              (c < 256 &&
-               (d != OP_ANY ||
+               (d != OP_ANY || !IS_NEWLINE(ptr)) &&
-                (ims & PCRE_DOTALL) != 0 ||
-                !IS_NEWLINE(ptr)
-               ) &&
                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
            {
            if (codevalue == OP_TYPEPOSQUERY)
-Line 909 
 for (;;)
+Line 1102 
 for (;;)
          {
          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
              (c < 256 &&
-               (d != OP_ANY ||
+               (d != OP_ANY || !IS_NEWLINE(ptr)) &&
-                (ims & PCRE_DOTALL) != 0 ||
-                !IS_NEWLINE(ptr)
-               ) &&
                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
            {
            if (codevalue == OP_TYPEPOSSTAR)
-Line 932 
 for (;;)
+Line 1122 
 for (;;)
          {
          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
              (c < 256 &&
-               (d != OP_ANY ||
+               (d != OP_ANY || !IS_NEWLINE(ptr)) &&
-                (ims & PCRE_DOTALL) != 0 ||
-                !IS_NEWLINE(ptr)
-               ) &&
                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
            {
            if (++count >= GET2(code, 1))
-Line 956 
 for (;;)
+Line 1143 
 for (;;)
          {
          if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
              (c < 256 &&
-               (d != OP_ANY ||
+               (d != OP_ANY || !IS_NEWLINE(ptr)) &&
-                (ims & PCRE_DOTALL) != 0 ||
-                !IS_NEWLINE(ptr)
-               ) &&
                ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
            {
            if (codevalue == OP_TYPEPOSUPTO)
-Line 990 
 for (;;)
+Line 1174 
 for (;;)
        if (clen > 0)
          {
          BOOL OK;
-         int category = _pcre_ucp_findprop(c, &chartype, &script);
+         const ucd_record * prop = GET_UCD(c);
          switch(code[2])
            {
            case PT_ANY:
-Line 998 
 for (;;)
+Line 1182 
 for (;;)
            break;
            case PT_LAMP:
-           OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;
+           OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
+             prop->chartype == ucp_Lt;
            break;
            case PT_GC:
-           OK = category == code[3];
+           OK = _pcre_ucp_gentype[prop->chartype] == code[3];
            break;
            case PT_PC:
-           OK = chartype == code[3];
+           OK = prop->chartype == code[3];
            break;
            case PT_SC:
-           OK = script == code[3];
+           OK = prop->script == code[3];
+           break;
+           /* These are specials for combination cases. */
+           case PT_ALNUM:
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
+                _pcre_ucp_gentype[prop->chartype] == ucp_N;
+           break;
+           case PT_SPACE:    /* Perl space */
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+                c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
+           break;
+           case PT_PXSPACE:  /* POSIX space */
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+                c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
+                c == CHAR_FF || c == CHAR_CR;
+           break;
+           case PT_WORD:
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
+                _pcre_ucp_gentype[prop->chartype] == ucp_N ||
+                c == CHAR_UNDERSCORE;
            break;
            /* Should never occur, but keep compilers from grumbling. */
-Line 1039 
 for (;;)
+Line 1248 
 for (;;)
        case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS:
        count = current_state->count;  /* Already matched */
        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
-       if (clen > 0 && _pcre_ucp_findprop(c, &chartype, &script) != ucp_M)
+       if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
          {
          const uschar *nptr = ptr + clen;
          int ncount = 0;
-Line 1053 
 for (;;)
+Line 1262 
 for (;;)
            int nd;
            int ndlen = 1;
            GETCHARLEN(nd, nptr, ndlen);
-           if (_pcre_ucp_findprop(nd, &chartype, &script) != ucp_M) break;
+           if (UCD_CATEGORY(nd) != ucp_M) break;
            ncount++;
            nptr += ndlen;
            }
-Line 1074 
 for (;;)
+Line 1283 
 for (;;)
          int ncount = 0;
          switch (c)
            {
-           case 0x000d:
-           if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
-           /* Fall through */
-           case 0x000a:
            case 0x000b:
            case 0x000c:
            case 0x0085:
            case 0x2028:
            case 0x2029:
+           if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
+           goto ANYNL01;
+           case 0x000d:
+           if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
+           /* Fall through */
+           ANYNL01:
+           case 0x000a:
            if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)
              {
              active_count--;           /* Remove non-match possibility */
-Line 1091 
 for (;;)
+Line 1305 
 for (;;)
            count++;
            ADD_NEW_DATA(-state_offset, count, ncount);
            break;
            default:
            break;
            }
-Line 1105 
 for (;;)
+Line 1320 
 for (;;)
        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
        if (clen > 0)
          {
          BOOL OK;
          switch (c)
            {
            case 0x000a:
-Line 1116 
 for (;;)
+Line 1331 
 for (;;)
            case 0x2028:
            case 0x2029:
            OK = TRUE;
            break;
            default:
            OK = FALSE;
            break;
            }
          if (OK == (d == OP_VSPACE))
            {
            if (count > 0 && codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSPLUS)
              {
              active_count--;           /* Remove non-match possibility */
-Line 1144 
 for (;;)
+Line 1359 
 for (;;)
        if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
        if (clen > 0)
          {
          BOOL OK;
          switch (c)
            {
            case 0x09:      /* HT */
-Line 1168 
 for (;;)
+Line 1383 
 for (;;)
            case 0x3000:    /* IDEOGRAPHIC SPACE */
            OK = TRUE;
            break;
            default:
            OK = FALSE;
            break;
            }
          if (OK == (d == OP_HSPACE))
            {
            if (count > 0 && codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSPLUS)
              {
              active_count--;           /* Remove non-match possibility */
-Line 1206 
 for (;;)
+Line 1421 
 for (;;)
        if (clen > 0)
          {
          BOOL OK;
-         int category = _pcre_ucp_findprop(c, &chartype, &script);
+         const ucd_record * prop = GET_UCD(c);
          switch(code[2])
            {
            case PT_ANY:
-Line 1214 
 for (;;)
+Line 1429 
 for (;;)
            break;
            case PT_LAMP:
-           OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;
+           OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
+             prop->chartype == ucp_Lt;
            break;
            case PT_GC:
-           OK = category == code[3];
+           OK = _pcre_ucp_gentype[prop->chartype] == code[3];
            break;
            case PT_PC:
-           OK = chartype == code[3];
+           OK = prop->chartype == code[3];
            break;
            case PT_SC:
-           OK = script == code[3];
+           OK = prop->script == code[3];
+           break;
+           /* These are specials for combination cases. */
+           case PT_ALNUM:
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
+                _pcre_ucp_gentype[prop->chartype] == ucp_N;
+           break;
+           case PT_SPACE:    /* Perl space */
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+                c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
+           break;
+           case PT_PXSPACE:  /* POSIX space */
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+                c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
+                c == CHAR_FF || c == CHAR_CR;
+           break;
+           case PT_WORD:
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
+                _pcre_ucp_gentype[prop->chartype] == ucp_N ||
+                c == CHAR_UNDERSCORE;
            break;
            /* Should never occur, but keep compilers from grumbling. */
-Line 1264 
 for (;;)
+Line 1504 
 for (;;)
        QS2:
        ADD_ACTIVE(state_offset + 2, 0);
-       if (clen > 0 && _pcre_ucp_findprop(c, &chartype, &script) != ucp_M)
+       if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
          {
          const uschar *nptr = ptr + clen;
          int ncount = 0;
-Line 1279 
 for (;;)
+Line 1519 
 for (;;)
            int nd;
            int ndlen = 1;
            GETCHARLEN(nd, nptr, ndlen);
-           if (_pcre_ucp_findprop(nd, &chartype, &script) != ucp_M) break;
+           if (UCD_CATEGORY(nd) != ucp_M) break;
            ncount++;
            nptr += ndlen;
            }
-Line 1307 
 for (;;)
+Line 1547 
 for (;;)
          int ncount = 0;
          switch (c)
            {
-           case 0x000d:
-           if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
-           /* Fall through */
-           case 0x000a:
            case 0x000b:
            case 0x000c:
            case 0x0085:
            case 0x2028:
            case 0x2029:
+           if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
+           goto ANYNL02;
+           case 0x000d:
+           if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
+           /* Fall through */
+           ANYNL02:
+           case 0x000a:
            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||
                codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)
              {
-Line 1324 
 for (;;)
+Line 1569 
 for (;;)
              }
            ADD_NEW_DATA(-(state_offset + count), 0, ncount);
            break;
            default:
            break;
            }
-Line 1346 
 for (;;)
+Line 1592 
 for (;;)
        ADD_ACTIVE(state_offset + 2, 0);
        if (clen > 0)
          {
          BOOL OK;
          switch (c)
            {
            case 0x000a:
-Line 1358 
 for (;;)
+Line 1604 
 for (;;)
            case 0x2029:
            OK = TRUE;
            break;
            default:
            OK = FALSE;
            break;
            }
          if (OK == (d == OP_VSPACE))
            {
            if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSSTAR ||
                codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSQUERY)
              {
-Line 1392 
 for (;;)
+Line 1638 
 for (;;)
        ADD_ACTIVE(state_offset + 2, 0);
        if (clen > 0)
          {
          BOOL OK;
          switch (c)
            {
            case 0x09:      /* HT */
-Line 1416 
 for (;;)
+Line 1662 
 for (;;)
            case 0x3000:    /* IDEOGRAPHIC SPACE */
            OK = TRUE;
            break;
            default:
            OK = FALSE;
            break;
            }
          if (OK == (d == OP_HSPACE))
            {
            if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSSTAR ||
                codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSQUERY)
              {
-Line 1447 
 for (;;)
+Line 1693 
 for (;;)
        if (clen > 0)
          {
          BOOL OK;
-         int category = _pcre_ucp_findprop(c, &chartype, &script);
+         const ucd_record * prop = GET_UCD(c);
          switch(code[4])
            {
            case PT_ANY:
-Line 1455 
 for (;;)
+Line 1701 
 for (;;)
            break;
            case PT_LAMP:
-           OK = chartype == ucp_Lu || chartype == ucp_Ll || chartype == ucp_Lt;
+           OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
+             prop->chartype == ucp_Lt;
            break;
            case PT_GC:
-           OK = category == code[5];
+           OK = _pcre_ucp_gentype[prop->chartype] == code[5];
            break;
            case PT_PC:
-           OK = chartype == code[5];
+           OK = prop->chartype == code[5];
            break;
            case PT_SC:
-           OK = script == code[5];
+           OK = prop->script == code[5];
+           break;
+           /* These are specials for combination cases. */
+           case PT_ALNUM:
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
+                _pcre_ucp_gentype[prop->chartype] == ucp_N;
+           break;
+           case PT_SPACE:    /* Perl space */
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+                c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR;
+           break;
+           case PT_PXSPACE:  /* POSIX space */
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_Z ||
+                c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
+                c == CHAR_FF || c == CHAR_CR;
+           break;
+           case PT_WORD:
+           OK = _pcre_ucp_gentype[prop->chartype] == ucp_L ||
+                _pcre_ucp_gentype[prop->chartype] == ucp_N ||
+                c == CHAR_UNDERSCORE;
            break;
            /* Should never occur, but keep compilers from grumbling. */
-Line 1500 
 for (;;)
+Line 1771 
 for (;;)
        if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT)
          { ADD_ACTIVE(state_offset + 4, 0); }
        count = current_state->count;  /* Number already matched */
-       if (clen > 0 && _pcre_ucp_findprop(c, &chartype, &script) != ucp_M)
+       if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
          {
          const uschar *nptr = ptr + clen;
          int ncount = 0;
-Line 1514 
 for (;;)
+Line 1785 
 for (;;)
            int nd;
            int ndlen = 1;
            GETCHARLEN(nd, nptr, ndlen);
-           if (_pcre_ucp_findprop(nd, &chartype, &script) != ucp_M) break;
+           if (UCD_CATEGORY(nd) != ucp_M) break;
            ncount++;
            nptr += ndlen;
            }
-Line 1539 
 for (;;)
+Line 1810 
 for (;;)
          int ncount = 0;
          switch (c)
            {
-           case 0x000d:
-           if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
-           /* Fall through */
-           case 0x000a:
            case 0x000b:
            case 0x000c:
            case 0x0085:
            case 0x2028:
            case 0x2029:
+           if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
+           goto ANYNL03;
+           case 0x000d:
+           if (ptr + 1 < end_subject && ptr[1] == 0x0a) ncount = 1;
+           /* Fall through */
+           ANYNL03:
+           case 0x000a:
            if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)
              {
              active_count--;           /* Remove non-match possibility */
-Line 1558 
 for (;;)
+Line 1834 
 for (;;)
            else
              { ADD_NEW_DATA(-state_offset, count, ncount); }
            break;
            default:
            break;
            }
-Line 1574 
 for (;;)
+Line 1851 
 for (;;)
        count = current_state->count;  /* Number already matched */
        if (clen > 0)
          {
          BOOL OK;
          switch (c)
            {
            case 0x000a:
-Line 1586 
 for (;;)
+Line 1863 
 for (;;)
            case 0x2029:
            OK = TRUE;
            break;
            default:
            OK = FALSE;
            }
          if (OK == (d == OP_VSPACE))
            {
            if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSUPTO)
              {
              active_count--;           /* Remove non-match possibility */
-Line 1616 
 for (;;)
+Line 1893 
 for (;;)
        count = current_state->count;  /* Number already matched */
        if (clen > 0)
          {
          BOOL OK;
          switch (c)
            {
            case 0x09:      /* HT */
-Line 1640 
 for (;;)
+Line 1917 
 for (;;)
            case 0x3000:    /* IDEOGRAPHIC SPACE */
            OK = TRUE;
            break;
            default:
            OK = FALSE;
            break;
            }
          if (OK == (d == OP_HSPACE))
            {
            if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSUPTO)
              {
              active_count--;           /* Remove non-match possibility */
-Line 1688 
 for (;;)
+Line 1965 
 for (;;)
            other case of the character. */
  #ifdef SUPPORT_UCP
-           othercase = _pcre_ucp_othercase(c);
+           othercase = UCD_OTHERCASE(c);
  #else
            othercase = NOTACHAR;
  #endif
-Line 1713 
 for (;;)
+Line 1990 
 for (;;)
        to wait for them to pass before continuing. */
        case OP_EXTUNI:
-       if (clen > 0 && _pcre_ucp_findprop(c, &chartype, &script) != ucp_M)
+       if (clen > 0 && UCD_CATEGORY(c) != ucp_M)
          {
          const uschar *nptr = ptr + clen;
          int ncount = 0;
-Line 1721 
 for (;;)
+Line 1998 
 for (;;)
            {
            int nclen = 1;
            GETCHARLEN(c, nptr, nclen);
-           if (_pcre_ucp_findprop(c, &chartype, &script) != ucp_M) break;
+           if (UCD_CATEGORY(c) != ucp_M) break;
            ncount++;
            nptr += nclen;
            }
-Line 1738 
 for (;;)
+Line 2015 
 for (;;)
        case OP_ANYNL:
        if (clen > 0) switch(c)
          {
-         case 0x000a:
          case 0x000b:
          case 0x000c:
          case 0x0085:
          case 0x2028:
          case 0x2029:
+         if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
+         case 0x000a:
          ADD_NEW(state_offset + 1, 0);
          break;
          case 0x000d:
          if (ptr + 1 < end_subject && ptr[1] == 0x0a)
            {
-Line 1771 
 for (;;)
+Line 2051 
 for (;;)
          case 0x2028:
          case 0x2029:
          break;
          default:
          ADD_NEW(state_offset + 1, 0);
          break;
          }
-Line 1791 
 for (;;)
+Line 2071 
 for (;;)
          case 0x2029:
          ADD_NEW(state_offset + 1, 0);
          break;
          default: break;
          }
        break;
-Line 1820 
 for (;;)
+Line 2100 
 for (;;)
          case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
          case 0x3000:    /* IDEOGRAPHIC SPACE */
          break;
          default:
          ADD_NEW(state_offset + 1, 0);
          break;
          }
-Line 1886 
 for (;;)
+Line 2166 
 for (;;)
            if (utf8 && d >= 128)
              {
  #ifdef SUPPORT_UCP
-             otherd = _pcre_ucp_othercase(d);
+             otherd = UCD_OTHERCASE(d);
  #endif  /* SUPPORT_UCP */
              }
            else
-Line 1924 
 for (;;)
+Line 2204 
 for (;;)
            if (utf8 && d >= 128)
              {
  #ifdef SUPPORT_UCP
-             otherd = _pcre_ucp_othercase(d);
+             otherd = UCD_OTHERCASE(d);
  #endif  /* SUPPORT_UCP */
              }
            else
-Line 1960 
 for (;;)
+Line 2240 
 for (;;)
            if (utf8 && d >= 128)
              {
  #ifdef SUPPORT_UCP
-             otherd = _pcre_ucp_othercase(d);
+             otherd = UCD_OTHERCASE(d);
  #endif  /* SUPPORT_UCP */
              }
            else
-Line 1992 
 for (;;)
+Line 2272 
 for (;;)
            if (utf8 && d >= 128)
              {
  #ifdef SUPPORT_UCP
-             otherd = _pcre_ucp_othercase(d);
+             otherd = UCD_OTHERCASE(d);
  #endif  /* SUPPORT_UCP */
              }
            else
-Line 2027 
 for (;;)
+Line 2307 
 for (;;)
            if (utf8 && d >= 128)
              {
  #ifdef SUPPORT_UCP
-             otherd = _pcre_ucp_othercase(d);
+             otherd = UCD_OTHERCASE(d);
  #endif  /* SUPPORT_UCP */
              }
            else
-Line 2088 
 for (;;)
+Line 2368 
 for (;;)
          points to the byte after the end of the class. If there is a
          quantifier, this is where it will be. */
-         next_state_offset = ecode - start_code;
+         next_state_offset = (int)(ecode - start_code);
          switch (*ecode)
            {
-Line 2135 
 for (;;)
+Line 2415 
 for (;;)
  /* ========================================================================== */
        /* These are the opcodes for fancy brackets of various kinds. We have
-       to use recursion in order to handle them. */
+       to use recursion in order to handle them. The "always failing" assertion
+       (?!) is optimised to OP_FAIL when compiling, so we have to support that,
+       though the other "backtracking verbs" are not supported. */
+       case OP_FAIL:
+       forced_fail++;    /* Count FAILs for multiple states */
+       break;
        case OP_ASSERT:
        case OP_ASSERT_NOT:
-Line 2153 
 for (;;)
+Line 2439 
 for (;;)
            md,                                   /* static match data */
            code,                                 /* this subexpression's code */
            ptr,                                  /* where we currently are */
-           ptr - start_subject,                  /* start offset */
+           (int)(ptr - start_subject),           /* start offset */
            local_offsets,                        /* offset vector */
            sizeof(local_offsets)/sizeof(int),    /* size of same */
            local_workspace,                      /* workspace vector */
-Line 2162 
 for (;;)
+Line 2448 
 for (;;)
            rlevel,                               /* function recursion level */
            recursing);                           /* pass on regex recursion */
+         if (rc == PCRE_ERROR_DFA_UITEM) return rc;
          if ((rc >= 0) == (codevalue == OP_ASSERT || codevalue == OP_ASSERTBACK))
-             { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }
+             { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); }
          }
        break;
-Line 2173 
 for (;;)
+Line 2460 
 for (;;)
          {
          int local_offsets[1000];
          int local_workspace[1000];
-         int condcode = code[LINK_SIZE+1];
+         int codelink = GET(code, 1);
+         int condcode;
+         /* Because of the way auto-callout works during compile, a callout item
+         is inserted between OP_COND and an assertion condition. This does not
+         happen for the other conditions. */
+         if (code[LINK_SIZE+1] == OP_CALLOUT)
+           {
+           rrc = 0;
+           if (pcre_callout != NULL)
+             {
+             pcre_callout_block cb;
+             cb.version          = 1;   /* Version 1 of the callout block */
+             cb.callout_number   = code[LINK_SIZE+2];
+             cb.offset_vector    = offsets;
+             cb.subject          = (PCRE_SPTR)start_subject;
+             cb.subject_length   = (int)(end_subject - start_subject);
+             cb.start_match      = (int)(current_subject - start_subject);
+             cb.current_position = (int)(ptr - start_subject);
+             cb.pattern_position = GET(code, LINK_SIZE + 3);
+             cb.next_item_length = GET(code, 3 + 2*LINK_SIZE);
+             cb.capture_top      = 1;
+             cb.capture_last     = -1;
+             cb.callout_data     = md->callout_data;
+             if ((rrc = (*pcre_callout)(&cb)) < 0) return rrc;   /* Abandon */
+             }
+           if (rrc > 0) break;                      /* Fail this thread */
+           code += _pcre_OP_lengths[OP_CALLOUT];    /* Skip callout data */
+           }
+         condcode = code[LINK_SIZE+1];
          /* Back reference conditions are not supported */
-         if (condcode == OP_CREF) return PCRE_ERROR_DFA_UCOND;
+         if (condcode == OP_CREF || condcode == OP_NCREF)
+           return PCRE_ERROR_DFA_UCOND;
          /* The DEFINE condition is always false */
          if (condcode == OP_DEF)
-           {
+           { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
-           ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0);
-           }
          /* The only supported version of OP_RREF is for the value RREF_ANY,
          which means "test if in any recursion". We can't test for specifically
          recursed groups. */
-         else if (condcode == OP_RREF)
+         else if (condcode == OP_RREF || condcode == OP_NRREF)
            {
            int value = GET2(code, LINK_SIZE+2);
            if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;
-           if (recursing > 0) { ADD_ACTIVE(state_offset + LINK_SIZE + 4, 0); }
+           if (recursing > 0)
-             else { ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0); }
+             { ADD_ACTIVE(state_offset + LINK_SIZE + 4, 0); }
+           else { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
            }
          /* Otherwise, the condition is an assertion */
-Line 2212 
 for (;;)
+Line 2530 
 for (;;)
              md,                                   /* fixed match data */
              asscode,                              /* this subexpression's code */
              ptr,                                  /* where we currently are */
-             ptr - start_subject,                  /* start offset */
+             (int)(ptr - start_subject),           /* start offset */
              local_offsets,                        /* offset vector */
              sizeof(local_offsets)/sizeof(int),    /* size of same */
              local_workspace,                      /* workspace vector */
-Line 2221 
 for (;;)
+Line 2539 
 for (;;)
              rlevel,                               /* function recursion level */
              recursing);                           /* pass on regex recursion */
+           if (rc == PCRE_ERROR_DFA_UITEM) return rc;
            if ((rc >= 0) ==
                  (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))
-             { ADD_ACTIVE(endasscode + LINK_SIZE + 1 - start_code, 0); }
+             { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); }
            else
-             { ADD_ACTIVE(state_offset + GET(code, 1) + LINK_SIZE + 1, 0); }
+             { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
            }
          }
        break;
-Line 2244 
 for (;;)
+Line 2563 
 for (;;)
            md,                                   /* fixed match data */
            start_code + GET(code, 1),            /* this subexpression's code */
            ptr,                                  /* where we currently are */
-           ptr - start_subject,                  /* start offset */
+           (int)(ptr - start_subject),           /* start offset */
            local_offsets,                        /* offset vector */
            sizeof(local_offsets)/sizeof(int),    /* size of same */
            local_workspace,                      /* workspace vector */
-Line 2296 
 for (;;)
+Line 2615 
 for (;;)
            md,                                   /* fixed match data */
            code,                                 /* this subexpression's code */
            ptr,                                  /* where we currently are */
-           ptr - start_subject,                  /* start offset */
+           (int)(ptr - start_subject),           /* start offset */
            local_offsets,                        /* offset vector */
            sizeof(local_offsets)/sizeof(int),    /* size of same */
            local_workspace,                      /* workspace vector */
-Line 2313 
 for (;;)
+Line 2632 
 for (;;)
            do { end_subpattern += GET(end_subpattern, 1); }
              while (*end_subpattern == OP_ALT);
-           next_state_offset = end_subpattern - start_code + LINK_SIZE + 1;
+           next_state_offset =
+             (int)(end_subpattern - start_code + LINK_SIZE + 1);
            /* If the end of this subpattern is KETRMAX or KETRMIN, we must
            arrange for the repeat state also to be added to the relevant list.
-Line 2321 
 for (;;)
+Line 2641 
 for (;;)
            repeat_state_offset = (*end_subpattern == OP_KETRMAX ||
                                   *end_subpattern == OP_KETRMIN)?
-             end_subpattern - start_code - GET(end_subpattern, 1) : -1;
+             (int)(end_subpattern - start_code - GET(end_subpattern, 1)) : -1;
            /* If we have matched an empty string, add the next state at the
            current character pointer. This is important so that the duplicate
-Line 2377 
 for (;;)
+Line 2697 
 for (;;)
        /* Handle callouts */
        case OP_CALLOUT:
+       rrc = 0;
        if (pcre_callout != NULL)
          {
-         int rrc;
          pcre_callout_block cb;
          cb.version          = 1;   /* Version 1 of the callout block */
          cb.callout_number   = code[1];
          cb.offset_vector    = offsets;
          cb.subject          = (PCRE_SPTR)start_subject;
-         cb.subject_length   = end_subject - start_subject;
+         cb.subject_length   = (int)(end_subject - start_subject);
-         cb.start_match      = current_subject - start_subject;
+         cb.start_match      = (int)(current_subject - start_subject);
-         cb.current_position = ptr - start_subject;
+         cb.current_position = (int)(ptr - start_subject);
          cb.pattern_position = GET(code, 2);
          cb.next_item_length = GET(code, 2 + LINK_SIZE);
          cb.capture_top      = 1;
          cb.capture_last     = -1;
          cb.callout_data     = md->callout_data;
          if ((rrc = (*pcre_callout)(&cb)) < 0) return rrc;   /* Abandon */
-         if (rrc == 0) { ADD_ACTIVE(state_offset + 2 + 2*LINK_SIZE, 0); }
          }
+       if (rrc == 0)
+         { ADD_ACTIVE(state_offset + _pcre_OP_lengths[OP_CALLOUT], 0); }
        break;
-Line 2411 
 for (;;)
+Line 2732 
 for (;;)
    /* We have finished the processing at the current subject character. If no
    new states have been set for the next character, we have found all the
    matches that we are going to find. If we are at the top level and partial
-   matching has been requested, check for appropriate conditions. */
+   matching has been requested, check for appropriate conditions.
+   The "forced_ fail" variable counts the number of (*F) encountered for the
+   character. If it is equal to the original active_count (saved in
+   workspace[1]) it means that (*F) was found on every active state. In this
+   case we don't want to give a partial match.
+   The "could_continue" variable is true if a state could have continued but
+   for the fact that the end of the subject was reached. */
    if (new_count <= 0)
      {
-     if (match_count < 0 &&                     /* No matches found */
+     if (rlevel == 1 &&                               /* Top level, and */
-         rlevel == 1 &&                         /* Top level match function */
+         could_continue &&                            /* Some could go on */
-         (md->moptions & PCRE_PARTIAL) != 0 &&  /* Want partial matching */
+         forced_fail != workspace[1] &&               /* Not all forced fail & */
+         (                                            /* either... */
+         (md->moptions & PCRE_PARTIAL_HARD) != 0      /* Hard partial */
+         ||                                           /* or... */
+         ((md->moptions & PCRE_PARTIAL_SOFT) != 0 &&  /* Soft partial and */
+          match_count < 0)                            /* no matches */
+         ) &&                                         /* And... */
          ptr >= end_subject &&                  /* Reached end of subject */
-         ptr > current_subject)                 /* Matched non-empty string */
+         ptr > md->start_used_ptr)              /* Inspected non-empty string */
        {
        if (offsetcount >= 2)
          {
-         offsets[0] = current_subject - start_subject;
+         offsets[0] = (int)(md->start_used_ptr - start_subject);
-         offsets[1] = end_subject - start_subject;
+         offsets[1] = (int)(end_subject - start_subject);
          }
        match_count = PCRE_ERROR_PARTIAL;
        }
-Line 2478 
 Returns:          > 0 => number of match
+Line 2813 
 Returns:          > 0 => number of match
                   < -1 => some kind of unexpected problem
  */
- PCRE_EXP_DEFN int
+ PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
  pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,
    const char *subject, int length, int start_offset, int options, int *offsets,
    int offsetcount, int *workspace, int wscount)
-Line 2509 
 if (re == NULL || subject == NULL || wor
+Line 2844 
 if (re == NULL || subject == NULL || wor
     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
  if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;
+ if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
  /* We need to find the pointer to any study data before we test for byte
  flipping, so we scan the extra_data block first. This may set two fields in the
-Line 2565 
 md->start_code = (const uschar *)argumen
+Line 2901 
 md->start_code = (const uschar *)argumen
      re->name_table_offset + re->name_count * re->name_entry_size;
  md->start_subject = (const unsigned char *)subject;
  md->end_subject = end_subject;
+ md->start_offset = start_offset;
  md->moptions = options;
  md->poptions = re->options;
+ /* If the BSR option is not set at match time, copy what was set
+ at compile time. */
+ if ((md->moptions & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) == 0)
+   {
+   if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
+     md->moptions |= re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE);
+ #ifdef BSR_ANYCRLF
+   else md->moptions |= PCRE_BSR_ANYCRLF;
+ #endif
+   }
  /* Handle different types of newline. The three bits give eight cases. If
  nothing is set at run time, whatever was used at compile time applies. */
-Line 2575 
 switch ((((options & PCRE_NEWLINE_BITS)
+Line 2924 
 switch ((((options & PCRE_NEWLINE_BITS)
           PCRE_NEWLINE_BITS)
    {
    case 0: newline = NEWLINE; break;   /* Compile-time default */
-   case PCRE_NEWLINE_CR: newline = '\r'; break;
+   case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
-   case PCRE_NEWLINE_LF: newline = '\n'; break;
+   case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
    case PCRE_NEWLINE_CR+
-        PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;
+        PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
    case PCRE_NEWLINE_ANY: newline = -1; break;
    case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
    default: return PCRE_ERROR_BADNEWLINE;
-Line 2614 
 back the character offset. */
+Line 2963 
 back the character offset. */
  #ifdef SUPPORT_UTF8
  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
    {
-   if (_pcre_valid_utf8((uschar *)subject, length) >= 0)
+   int tb;
-     return PCRE_ERROR_BADUTF8;
+   if ((tb = _pcre_valid_utf8((uschar *)subject, length)) >= 0)
+     return (tb == length && (options & PCRE_PARTIAL_HARD) != 0)?
+       PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
    if (start_offset > 0 && start_offset < length)
      {
-     int tb = ((uschar *)subject)[start_offset];
+     tb = ((USPTR)subject)[start_offset] & 0xc0;
-     if (tb > 127)
+     if (tb == 0x80) return PCRE_ERROR_BADUTF8_OFFSET;
-       {
-       tb &= 0xc0;
-       if (tb != 0 && tb != 0xc0) return PCRE_ERROR_BADUTF8_OFFSET;
-       }
      }
    }
  #endif
-Line 2638 
 if (md->tables == NULL) md->tables = _pc
+Line 2985 
 if (md->tables == NULL) md->tables = _pc
  used in a loop when finding where to start. */
  lcc = md->tables + lcc_offset;
- startline = (re->options & PCRE_STARTLINE) != 0;
+ startline = (re->flags & PCRE_STARTLINE) != 0;
  firstline = (re->options & PCRE_FIRSTLINE) != 0;
  /* Set up the first character to match, if available. The first_byte value is
-Line 2649 
 studied, there may be a bitmap of possib
+Line 2996 
 studied, there may be a bitmap of possib
  if (!anchored)
    {
-   if ((re->options & PCRE_FIRSTSET) != 0)
+   if ((re->flags & PCRE_FIRSTSET) != 0)
      {
      first_byte = re->first_byte & 255;
      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
-Line 2657 
 if (!anchored)
+Line 3004 
 if (!anchored)
      }
    else
      {
-     if (startline && study != NULL &&
+     if (!startline && study != NULL &&
-          (study->options & PCRE_STUDY_MAPPED) != 0)
+          (study->flags & PCRE_STUDY_MAPPED) != 0)
        start_bits = study->start_bits;
      }
    }
-Line 2666 
 if (!anchored)
+Line 3013 
 if (!anchored)
  /* For anchored or unanchored matches, there may be a "last known required
  character" set. */
- if ((re->options & PCRE_REQCHSET) != 0)
+ if ((re->flags & PCRE_REQCHSET) != 0)
    {
    req_byte = re->req_byte & 255;
    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
-Line 2674 
 if ((re->options & PCRE_REQCHSET) != 0)
+Line 3021 
 if ((re->options & PCRE_REQCHSET) != 0)
    }
  /* Call the main matching function, looping for a non-anchored regex after a
- failed match. Unless restarting, optimize by moving to the first match
+ failed match. If not restarting, perform certain optimizations at the start of
- character if possible, when not anchored. Then unless wanting a partial match,
+ a match. */
- check for a required later character. */
  for (;;)
    {
-Line 2686 
 for (;;)
+Line 3032 
 for (;;)
      {
      const uschar *save_end_subject = end_subject;
-     /* 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
-     start of the match is constrained to the first line of a multiline string.
+     line of a multiline string. Implement this by temporarily adjusting
-     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
-     scanning at a newline. If the match fails at the newline, later code breaks
+     the newline, later code breaks this loop. */
-     this loop. */
      if (firstline)
        {
-       const uschar *t = current_subject;
+       USPTR t = current_subject;
+ #ifdef SUPPORT_UTF8
+       if (utf8)
+         {
+         while (t < md->end_subject && !IS_NEWLINE(t))
+           {
+           t++;
+           while (t < end_subject && (*t & 0xc0) == 0x80) t++;
+           }
+         }
+       else
+ #endif
        while (t < md->end_subject && !IS_NEWLINE(t)) t++;
        end_subject = t;
        }
-     if (first_byte >= 0)
+     /* There are some optimizations that avoid running the match if a known
+     starting point is not found. However, there is an option that disables
+     these, for testing and for ensuring that all callouts do actually occur.
+     The option can be set in the regex by (*NO_START_OPT) or passed in
+     match-time options. */
+     if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0)
        {
-       if (first_byte_caseless)
+       /* Advance to a known first byte. */
-         while (current_subject < end_subject &&
-                lcc[*current_subject] != first_byte)
+       if (first_byte >= 0)
-           current_subject++;
+         {
-       else
+         if (first_byte_caseless)
-         while (current_subject < end_subject && *current_subject != first_byte)
+           while (current_subject < end_subject &&
-           current_subject++;
+                  lcc[*current_subject] != first_byte)
-       }
+             current_subject++;
+         else
+           while (current_subject < end_subject &&
+                  *current_subject != first_byte)
+             current_subject++;
+         }
-     /* Or to just after a linebreak for a multiline match if possible */
+       /* Or to just after a linebreak for a multiline match if possible */
-     else if (startline)
+       else if (startline)
-       {
-       if (current_subject > md->start_subject + start_offset)
          {
-         while (current_subject <= end_subject && !WAS_NEWLINE(current_subject))
+         if (current_subject > md->start_subject + start_offset)
-           current_subject++;
+           {
+ #ifdef SUPPORT_UTF8
+           if (utf8)
+             {
+             while (current_subject < end_subject &&
+                    !WAS_NEWLINE(current_subject))
+               {
+               current_subject++;
+               while(current_subject < end_subject &&
+                     (*current_subject & 0xc0) == 0x80)
+                 current_subject++;
+               }
+             }
+           else
+ #endif
+           while (current_subject < end_subject && !WAS_NEWLINE(current_subject))
+             current_subject++;
-         /* If we have just passed a CR and the newline option is ANY or
+           /* If we have just passed a CR and the newline option is ANY or
-         ANYCRLF, and we are now at a LF, advance the match position by one more
+           ANYCRLF, and we are now at a LF, advance the match position by one
-         character. */
+           more character. */
-         if (current_subject[-1] == '\r' &&
+           if (current_subject[-1] == CHAR_CR &&
-              (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
+                (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
-              current_subject < end_subject &&
+                current_subject < end_subject &&
-              *current_subject == '\n')
+                *current_subject == CHAR_NL)
-           current_subject++;
+             current_subject++;
+           }
          }
-       }
-     /* Or to a non-unique first char after study */
+       /* Or to a non-unique first char after study */
-     else if (start_bits != NULL)
+       else if (start_bits != NULL)
-       {
-       while (current_subject < end_subject)
          {
-         register unsigned int c = *current_subject;
+         while (current_subject < end_subject)
-         if ((start_bits[c/8] & (1 << (c&7))) == 0) current_subject++;
+           {
+           register unsigned int c = *current_subject;
+           if ((start_bits[c/8] & (1 << (c&7))) == 0)
+             {
+             current_subject++;
+ #ifdef SUPPORT_UTF8
+             if (utf8)
+               while(current_subject < end_subject &&
+                     (*current_subject & 0xc0) == 0x80) current_subject++;
+ #endif
+             }
            else break;
+           }
          }
        }
      /* Restore fudged end_subject */
      end_subject = save_end_subject;
-     }
-   /* If req_byte is set, we know that that character must appear in the subject
-   for the match to succeed. If the first character is set, req_byte must be
-   later in the subject; otherwise the test starts at the match point. This
-   optimization can save a huge amount of work in patterns with nested unlimited
-   repeats that aren't going to match. Writing separate code for cased/caseless
-   versions makes it go faster, as does using an autoincrement and backing off
-   on a match.
-   HOWEVER: when the subject string is very, very long, searching to its end can
-   take a long time, and give bad performance on quite ordinary patterns. This
-   showed up when somebody was matching /^C/ on a 32-megabyte string... so we
-   don't do this when the string is sufficiently long.
-   ALSO: this processing is disabled when partial matching is requested.
-   */
-   if (req_byte >= 0 &&
-       end_subject - current_subject < REQ_BYTE_MAX &&
-       (options & PCRE_PARTIAL) == 0)
-     {
-     register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);
-     /* We don't need to repeat the search if we haven't yet reached the
+     /* The following two optimizations are disabled for partial matching or if
-     place we found it at last time. */
+     disabling is explicitly requested (and of course, by the test above, this
+     code is not obeyed when restarting after a partial match). */
-     if (p > req_byte_ptr)
+     if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&
+         (options & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) == 0)
        {
-       if (req_byte_caseless)
+       /* If the pattern was studied, a minimum subject length may be set. This
-         {
+       is a lower bound; no actual string of that length may actually match the
-         while (p < end_subject)
+       pattern. Although the value is, strictly, in characters, we treat it as
-           {
+       bytes to avoid spending too much time in this optimization. */
-           register int pp = *p++;
-           if (pp == req_byte || pp == req_byte2) { p--; break; }
+       if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
-           }
+           (pcre_uint32)(end_subject - current_subject) < study->minlength)
-         }
+         return PCRE_ERROR_NOMATCH;
-       else
+       /* If req_byte is set, we know that that character must appear in the
+       subject for the match to succeed. If the first character is set, req_byte
+       must be later in the subject; otherwise the test starts at the match
+       point. This optimization can save a huge amount of work in patterns with
+       nested unlimited repeats that aren't going to match. Writing separate
+       code for cased/caseless versions makes it go faster, as does using an
+       autoincrement and backing off on a match.
+       HOWEVER: when the subject string is very, very long, searching to its end
+       can take a long time, and give bad performance on quite ordinary
+       patterns. This showed up when somebody was matching /^C/ on a 32-megabyte
+       string... so we don't do this when the string is sufficiently long. */
+       if (req_byte >= 0 && end_subject - current_subject < REQ_BYTE_MAX)
          {
-         while (p < end_subject)
+         register const uschar *p = current_subject + ((first_byte >= 0)? 1 : 0);
+         /* We don't need to repeat the search if we haven't yet reached the
+         place we found it at last time. */
+         if (p > req_byte_ptr)
            {
-           if (*p++ == req_byte) { p--; break; }
+           if (req_byte_caseless)
-           }
+             {
-         }
+             while (p < end_subject)
+               {
+               register int pp = *p++;
+               if (pp == req_byte || pp == req_byte2) { p--; break; }
+               }
+             }
+           else
+             {
+             while (p < end_subject)
+               {
+               if (*p++ == req_byte) { p--; break; }
+               }
+             }
-       /* If we can't find the required character, break the matching loop,
+           /* If we can't find the required character, break the matching loop,
-       which will cause a return or PCRE_ERROR_NOMATCH. */
+           which will cause a return or PCRE_ERROR_NOMATCH. */
-       if (p >= end_subject) break;
+           if (p >= end_subject) break;
-       /* If we have found the required character, save the point where we
+           /* If we have found the required character, save the point where we
-       found it, so that we don't search again next time round the loop if
+           found it, so that we don't search again next time round the loop if
-       the start hasn't passed this character yet. */
+           the start hasn't passed this character yet. */
-       req_byte_ptr = p;
+           req_byte_ptr = p;
+           }
+         }
        }
-     }
+     }   /* End of optimizations that are done when not restarting */
    /* OK, now we can do the business */
+   md->start_used_ptr = current_subject;
    rc = internal_dfa_exec(
      md,                                /* fixed match data */
      md->start_code,                    /* this subexpression's code */
-Line 2836 
 for (;;)
+Line 3240 
 for (;;)
      }
    if (current_subject > end_subject) break;
-   /* If we have just passed a CR and the newline option is CRLF or ANY or
+   /* If we have just passed a CR and we are now at a LF, and the pattern does
-   ANYCRLF, and we are now at a LF, advance the match position by one more
+   not contain any explicit matches for \r or \n, and the newline option is CRLF
-   character. */
+   or ANY or ANYCRLF, advance the match position by one more character. */
-   if (current_subject[-1] == '\r' &&
+   if (current_subject[-1] == CHAR_CR &&
-        (md->nltype == NLTYPE_ANY ||
+       current_subject < end_subject &&
-         md->nltype == NLTYPE_ANYCRLF ||
+       *current_subject == CHAR_NL &&
-         md->nllen == 2) &&
+       (re->flags & PCRE_HASCRORLF) == 0 &&
-        current_subject < end_subject &&
+         (md->nltype == NLTYPE_ANY ||
-        *current_subject == '\n')
+          md->nltype == NLTYPE_ANYCRLF ||
+          md->nllen == 2))
      current_subject++;
    }   /* "Bumpalong" loop */

 Legend:



Removed from v.178
 


changed lines


 
Added in v.579
 Legend:



Removed from v.178
 


changed lines


 
Added in v.579
-Removed from v.178
+Added in v.579

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12