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

Diff of /code/trunk/pcre_dfa_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 226 by ph10,
Tue Aug 21 11:46:08 2007 UTC
+revision 606 by ph10,
Mon Jun  6 17:46:22 2011 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-2011 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>
+ #include "config.h"
  #endif
  #define NLBLOCK md             /* Block containing newline information */
-Line 60 
 applications. */
+Line 89 
 applications. */
  #define SP "                   "
  /*************************************************
  *      Code parameters and static tables         *
  *************************************************/
-Line 78 
 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                     */
-, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */
+,                             /* \X                                     */
+, 0, 0, 0, 0, 0,              /* \Z, \z, ^, ^M, $, $M                   */
 ,                             /* Char                                   */
-,                             /* Charnc                                 */
+,                             /* Chari                                  */
 ,                             /* not                                    */
+,                             /* noti                                   */
    /* Positive single-char repeats                                          */
 , 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
 , 3, 3,                       /* upto, minupto, exact                   */
 , 1, 1, 3,                    /* *+, ++, ?+, upto+                      */
+, 1, 1, 1, 1, 1,              /* *I, *?I, +I, +?I, ?I, ??I              */
+, 3, 3,                       /* upto I, minupto I, exact I             */
+, 1, 1, 3,                    /* *+I, ++I, ?+I, upto+I                  */
    /* Negative single-char repeats - only for chars < 256                   */
 , 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */
 , 3, 3,                       /* NOT upto, minupto, exact               */
-, 1, 1, 3,                    /* NOT *+, ++, ?+, updo+                  */
+, 1, 1, 3,                    /* NOT *+, ++, ?+, upto+                  */
+, 1, 1, 1, 1, 1,              /* NOT *I, *?I, +I, +?I, ?I, ??I          */
+, 3, 3,                       /* NOT upto I, minupto I, exact I         */
+, 1, 1, 3,                    /* NOT *+I, ++I, ?+I, upto+I              */
    /* Positive type repeats                                                 */
 , 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */
 , 3, 3,                       /* Type upto, minupto, exact              */
-Line 114 
 static uschar coptable[] = {
+Line 151 
 static uschar coptable[] = {
 ,                             /* NCLASS                                 */
 ,                             /* XCLASS - variable length               */
 ,                             /* REF                                    */
+,                             /* REFI                                   */
 ,                             /* RECURSE                                */
 ,                             /* CALLOUT                                */
 ,                             /* Alt                                    */
 ,                             /* Ket                                    */
 ,                             /* KetRmax                                */
 ,                             /* KetRmin                                */
+,                             /* KetRpos                                */
 ,                             /* Assert                                 */
 ,                             /* Assert not                             */
 ,                             /* Assert behind                          */
 ,                             /* Assert behind not                      */
 ,                             /* Reverse                                */
-, 0, 0, 0,                    /* ONCE, BRA, CBRA, COND                  */
+, 0, 0, 0, 0, 0,              /* ONCE, BRA, BRAPOS, CBRA, CBRAPOS, COND */
-, 0, 0,                       /* SBRA, SCBRA, SCOND                     */
+, 0, 0, 0, 0,                 /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND  */
-,                             /* CREF                                   */
+, 0,                          /* CREF, NCREF                            */
-,                             /* RREF                                   */
+, 0,                          /* RREF, NRREF                            */
 ,                             /* DEF                                    */
-, 0,                          /* BRAZERO, BRAMINZERO                    */
+, 0, 0,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */
-, 0, 0, 0,                    /* PRUNE, SKIP, THEN, COMMIT              */
+, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG,                */
-, 0                           /* FAIL, ACCEPT                           */
+, 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, 0,              /* \Z, \z, ^, ^M, $, $M                   */
+,                             /* Char                                   */
+,                             /* Chari                                  */
+,                             /* not                                    */
+,                             /* noti                                   */
+   /* Positive single-char repeats                                          */
+, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
+, 1, 1,                       /* upto, minupto, exact                   */
+, 1, 1, 1,                    /* *+, ++, ?+, upto+                      */
+, 1, 1, 1, 1, 1,              /* *I, *?I, +I, +?I, ?I, ??I              */
+, 1, 1,                       /* upto I, minupto I, exact I             */
+, 1, 1, 1,                    /* *+I, ++I, ?+I, upto+I                  */
+   /* 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+                  */
+, 1, 1, 1, 1, 1,              /* NOT *I, *?I, +I, +?I, ?I, ??I          */
+, 1, 1,                       /* NOT upto I, minupto I, exact I         */
+, 1, 1, 1,                    /* NOT *+I, ++I, ?+I, upto+I              */
+   /* 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                                    */
+,                             /* REFI                                   */
+,                             /* RECURSE                                */
+,                             /* CALLOUT                                */
+,                             /* Alt                                    */
+,                             /* Ket                                    */
+,                             /* KetRmax                                */
+,                             /* KetRmin                                */
+,                             /* KetRpos                                */
+,                             /* Assert                                 */
+,                             /* Assert not                             */
+,                             /* Assert behind                          */
+,                             /* Assert behind not                      */
+,                             /* Reverse                                */
+, 0, 0, 0, 0, 0,              /* ONCE, BRA, BRAPOS, CBRA, CBRAPOS, COND */
+, 0, 0, 0, 0,                 /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND  */
+, 0,                          /* CREF, NCREF                            */
+, 0,                          /* RREF, NRREF                            */
+,                             /* DEF                                    */
+, 0, 0,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */
+, 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 163 
 these structures in, is a vector of ints
+Line 270 
 these structures in, is a vector of ints
  typedef struct stateblock {
    int offset;                     /* Offset to opcode */
    int count;                      /* Count for repeats */
-   int ims;                        /* ims flag bits */
    int data;                       /* Some use extra data */
  } stateblock;
  #define INTS_PER_STATEBLOCK  (sizeof(stateblock)/sizeof(int))
- #ifdef DEBUG
+ #ifdef PCRE_DEBUG
  /*************************************************
  *             Print character string             *
  *************************************************/
-Line 219 
 Arguments:
+Line 325 
 Arguments:
    offsetcount       size of same
    workspace         vector of workspace
    wscount           size of same
-   ims               the current ims flags
    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 236 
 for the current character, one for the f
+Line 341 
 for the current character, one for the f
      { \
      next_active_state->offset = (x); \
      next_active_state->count  = (y); \
-     next_active_state->ims    = ims; \
      next_active_state++; \
      DPRINTF(("%.*sADD_ACTIVE(%d,%d)\n", rlevel*2-2, SP, (x), (y))); \
      } \
-Line 247 
 for the current character, one for the f
+Line 351 
 for the current character, one for the f
      { \
      next_active_state->offset = (x); \
      next_active_state->count  = (y); \
-     next_active_state->ims    = ims; \
      next_active_state->data   = (z); \
      next_active_state++; \
      DPRINTF(("%.*sADD_ACTIVE_DATA(%d,%d,%d)\n", rlevel*2-2, SP, (x), (y), (z))); \
-Line 259 
 for the current character, one for the f
+Line 362 
 for the current character, one for the f
      { \
      next_new_state->offset = (x); \
      next_new_state->count  = (y); \
-     next_new_state->ims    = ims; \
      next_new_state++; \
      DPRINTF(("%.*sADD_NEW(%d,%d)\n", rlevel*2-2, SP, (x), (y))); \
      } \
-Line 270 
 for the current character, one for the f
+Line 372 
 for the current character, one for the f
      { \
      next_new_state->offset = (x); \
      next_new_state->count  = (y); \
-     next_new_state->ims    = ims; \
      next_new_state->data   = (z); \
      next_new_state++; \
      DPRINTF(("%.*sADD_NEW_DATA(%d,%d,%d)\n", rlevel*2-2, SP, (x), (y), (z))); \
-Line 289 
 internal_dfa_exec(
+Line 390 
 internal_dfa_exec(
    int offsetcount,
    int *workspace,
    int wscount,
-   int ims,
    int  rlevel,
    int  recursing)
  {
-Line 337 
 next_new_state = new_states = active_sta
+Line 437 
 next_new_state = new_states = active_sta
  new_count = 0;
  first_op = this_start_code + 1 + LINK_SIZE +
-   ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);
+   ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA ||
+     *this_start_code == OP_CBRAPOS || *this_start_code == OP_SCBRAPOS)? 2:0);
  /* The first thing in any (sub) pattern is a bracket of some sort. Push all
  the alternative states onto the list, and find out where the end is. This
-Line 386 
 if (*first_op == OP_REVERSE)
+Line 487 
 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 398 
 if (*first_op == OP_REVERSE)
+Line 504 
 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 431 
 else
+Line 537 
 else
    else
      {
      int length = 1 + LINK_SIZE +
-       ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA)? 2:0);
+       ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA ||
+         *this_start_code == OP_CBRAPOS || *this_start_code == OP_SCBRAPOS)?
+: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 454 
 for (;;)
+Line 562 
 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 467 
 for (;;)
+Line 577 
 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 509 
 for (;;)
+Line 619 
 for (;;)
    for (i = 0; i < active_count; i++)
      {
      stateblock *current_state = active_states + i;
+     BOOL caseless = FALSE;
      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);
          else printf("0x%02x\n", c);
  #endif
-     /* This variable is referred to implicity in the ADD_xxx macros. */
-     ims = current_state->ims;
      /* A negative offset is a special case meaning "hold off going to this
      (negated) state until the number of characters in the data field have
      been skipped". */
-Line 546 
 for (;;)
+Line 650 
 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 563 
 for (;;)
+Line 669 
 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 609 
 for (;;)
+Line 721 
 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
+       on with the next opcode. For repeating opcodes, also add the repeat
-       PCRE_NOTEMPTY is set, save the match data, shifting up all previous
+       state. Note that KETRPOS will always be encountered at the end of the
+       subpattern, because the possessive subpattern repeats are always handled
+       using recursive calls. Thus, it never adds any new states.
+       At the end of the (sub)pattern, unless we have an empty string and
+       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:
        case OP_KETRMIN:
        case OP_KETRMAX:
+       case OP_KETRPOS:
        if (code != end_code)
          {
          ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0);
-Line 627 
 for (;;)
+Line 758 
 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 658 
 for (;;)
+Line 795 
 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 666 
 for (;;)
+Line 803 
 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 675 
 for (;;)
+Line 812 
 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 690 
 for (;;)
+Line 827 
 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;
        /*-----------------------------------------------------------------*/
        case OP_CIRC:
-       if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||
+       if (ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0)
-           ((ims & PCRE_MULTILINE) != 0 &&
-             ptr != end_subject &&
-             WAS_NEWLINE(ptr)))
          { ADD_ACTIVE(state_offset + 1, 0); }
        break;
        /*-----------------------------------------------------------------*/
-       case OP_EOD:
+       case OP_CIRCM:
-       if (ptr >= end_subject) { ADD_ACTIVE(state_offset + 1, 0); }
+       if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||
+           (ptr != end_subject && WAS_NEWLINE(ptr)))
+         { ADD_ACTIVE(state_offset + 1, 0); }
        break;
        /*-----------------------------------------------------------------*/
-       case OP_OPT:
+       case OP_EOD:
-       ims = code[1];
+       if (ptr >= end_subject)
-       ADD_ACTIVE(state_offset + 2, 0);
+         {
+         if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
+           could_continue = TRUE;
+         else { ADD_ACTIVE(state_offset + 1, 0); }
+         }
        break;
        /*-----------------------------------------------------------------*/
-Line 732 
 for (;;)
+Line 879 
 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 746 
 for (;;)
+Line 901 
 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;
-                ((ims & PCRE_MULTILINE) != 0 || ptr == end_subject - md->nllen)
+         else if (clen == 0 ||
+             ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&
+                (ptr == end_subject - md->nllen)
              ))
            { ADD_ACTIVE(state_offset + 1, 0); }
          }
-       else if ((ims & PCRE_MULTILINE) != 0 && IS_NEWLINE(ptr))
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_DOLLM:
+       if ((md->moptions & PCRE_NOTEOL) == 0)
+         {
+         if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
+           could_continue = TRUE;
+         else if (clen == 0 ||
+             ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr)))
+           { ADD_ACTIVE(state_offset + 1, 0); }
+         }
+       else if (IS_NEWLINE(ptr))
          { ADD_ACTIVE(state_offset + 1, 0); }
        break;
-Line 784 
 for (;;)
+Line 953 
 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 812 
 for (;;)
+Line 1007 
 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 820 
 for (;;)
+Line 1015 
 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 852 
 for (;;)
+Line 1072 
 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 864 
 for (;;)
+Line 1084 
 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 890 
 for (;;)
+Line 1107 
 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 915 
 for (;;)
+Line 1129 
 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 938 
 for (;;)
+Line 1149 
 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 962 
 for (;;)
+Line 1170 
 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 996 
 for (;;)
+Line 1201 
 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 1004 
 for (;;)
+Line 1209 
 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 1045 
 for (;;)
+Line 1275 
 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 1059 
 for (;;)
+Line 1289 
 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 1080 
 for (;;)
+Line 1310 
 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 1097 
 for (;;)
+Line 1332 
 for (;;)
            count++;
            ADD_NEW_DATA(-state_offset, count, ncount);
            break;
            default:
            break;
            }
-Line 1212 
 for (;;)
+Line 1448 
 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 1220 
 for (;;)
+Line 1456 
 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 1270 
 for (;;)
+Line 1531 
 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 1285 
 for (;;)
+Line 1546 
 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 1313 
 for (;;)
+Line 1574 
 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 1330 
 for (;;)
+Line 1596 
 for (;;)
              }
            ADD_NEW_DATA(-(state_offset + count), 0, ncount);
            break;
            default:
            break;
            }
-Line 1453 
 for (;;)
+Line 1720 
 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 1461 
 for (;;)
+Line 1728 
 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 1506 
 for (;;)
+Line 1798 
 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 1520 
 for (;;)
+Line 1812 
 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 1545 
 for (;;)
+Line 1837 
 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 1564 
 for (;;)
+Line 1861 
 for (;;)
            else
              { ADD_NEW_DATA(-state_offset, count, ncount); }
            break;
            default:
            break;
            }
-Line 1679 
 for (;;)
+Line 1977 
 for (;;)
        break;
        /*-----------------------------------------------------------------*/
-       case OP_CHARNC:
+       case OP_CHARI:
        if (clen == 0) break;
  #ifdef SUPPORT_UTF8
-Line 1694 
 for (;;)
+Line 1992 
 for (;;)
            other case of the character. */
  #ifdef SUPPORT_UCP
-           othercase = _pcre_ucp_othercase(c);
+           othercase = UCD_OTHERCASE(c);
  #else
            othercase = NOTACHAR;
  #endif
-Line 1719 
 for (;;)
+Line 2017 
 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 1727 
 for (;;)
+Line 2025 
 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 1744 
 for (;;)
+Line 2042 
 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 1862 
 for (;;)
+Line 2163 
 for (;;)
        break;
        /*-----------------------------------------------------------------*/
-       /* Match a negated single character. This is only used for one-byte
+       /* Match a negated single character casefully. This is only used for
-       characters, that is, we know that d < 256. The character we are
+       one-byte characters, that is, we know that d < 256. The character we are
        checking (c) can be multibyte. */
        case OP_NOT:
-       if (clen > 0)
+       if (clen > 0 && c != d) { ADD_NEW(state_offset + dlen + 1, 0); }
-         {
-         unsigned int otherd = ((ims & PCRE_CASELESS) != 0)? fcc[d] : d;
-         if (c != d && c != otherd) { ADD_NEW(state_offset + dlen + 1, 0); }
-         }
        break;
        /*-----------------------------------------------------------------*/
+       /* Match a negated single character caselessly. This is only used for
+       one-byte characters, that is, we know that d < 256. The character we are
+       checking (c) can be multibyte. */
+       case OP_NOTI:
+       if (clen > 0 && c != d && c != fcc[d])
+         { ADD_NEW(state_offset + dlen + 1, 0); }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_PLUSI:
+       case OP_MINPLUSI:
+       case OP_POSPLUSI:
+       case OP_NOTPLUSI:
+       case OP_NOTMINPLUSI:
+       case OP_NOTPOSPLUSI:
+       caseless = TRUE;
+       codevalue -= OP_STARI - OP_STAR;
+       /* Fall through */
        case OP_PLUS:
        case OP_MINPLUS:
        case OP_POSPLUS:
-Line 1886 
 for (;;)
+Line 2203 
 for (;;)
        if (clen > 0)
          {
          unsigned int otherd = NOTACHAR;
-         if ((ims & PCRE_CASELESS) != 0)
+         if (caseless)
            {
  #ifdef SUPPORT_UTF8
            if (utf8 && d >= 128)
              {
  #ifdef SUPPORT_UCP
-             otherd = _pcre_ucp_othercase(d);
+             otherd = UCD_OTHERCASE(d);
  #endif  /* SUPPORT_UCP */
              }
            else
-Line 1914 
 for (;;)
+Line 2231 
 for (;;)
        break;
        /*-----------------------------------------------------------------*/
+       case OP_QUERYI:
+       case OP_MINQUERYI:
+       case OP_POSQUERYI:
+       case OP_NOTQUERYI:
+       case OP_NOTMINQUERYI:
+       case OP_NOTPOSQUERYI:
+       caseless = TRUE;
+       codevalue -= OP_STARI - OP_STAR;
+       /* Fall through */
        case OP_QUERY:
        case OP_MINQUERY:
        case OP_POSQUERY:
-Line 1924 
 for (;;)
+Line 2250 
 for (;;)
        if (clen > 0)
          {
          unsigned int otherd = NOTACHAR;
-         if ((ims & PCRE_CASELESS) != 0)
+         if (caseless)
            {
  #ifdef SUPPORT_UTF8
            if (utf8 && d >= 128)
              {
  #ifdef SUPPORT_UCP
-             otherd = _pcre_ucp_othercase(d);
+             otherd = UCD_OTHERCASE(d);
  #endif  /* SUPPORT_UCP */
              }
            else
-Line 1950 
 for (;;)
+Line 2276 
 for (;;)
        break;
        /*-----------------------------------------------------------------*/
+       case OP_STARI:
+       case OP_MINSTARI:
+       case OP_POSSTARI:
+       case OP_NOTSTARI:
+       case OP_NOTMINSTARI:
+       case OP_NOTPOSSTARI:
+       caseless = TRUE;
+       codevalue -= OP_STARI - OP_STAR;
+       /* Fall through */
        case OP_STAR:
        case OP_MINSTAR:
        case OP_POSSTAR:
-Line 1960 
 for (;;)
+Line 2295 
 for (;;)
        if (clen > 0)
          {
          unsigned int otherd = NOTACHAR;
-         if ((ims & PCRE_CASELESS) != 0)
+         if (caseless)
            {
  #ifdef SUPPORT_UTF8
            if (utf8 && d >= 128)
              {
  #ifdef SUPPORT_UCP
-             otherd = _pcre_ucp_othercase(d);
+             otherd = UCD_OTHERCASE(d);
  #endif  /* SUPPORT_UCP */
              }
            else
-Line 1986 
 for (;;)
+Line 2321 
 for (;;)
        break;
        /*-----------------------------------------------------------------*/
+       case OP_EXACTI:
+       case OP_NOTEXACTI:
+       caseless = TRUE;
+       codevalue -= OP_STARI - OP_STAR;
+       /* Fall through */
        case OP_EXACT:
        case OP_NOTEXACT:
        count = current_state->count;  /* Number already matched */
        if (clen > 0)
          {
          unsigned int otherd = NOTACHAR;
-         if ((ims & PCRE_CASELESS) != 0)
+         if (caseless)
            {
  #ifdef SUPPORT_UTF8
            if (utf8 && d >= 128)
              {
  #ifdef SUPPORT_UCP
-             otherd = _pcre_ucp_othercase(d);
+             otherd = UCD_OTHERCASE(d);
  #endif  /* SUPPORT_UCP */
              }
            else
-Line 2016 
 for (;;)
+Line 2356 
 for (;;)
        break;
        /*-----------------------------------------------------------------*/
+       case OP_UPTOI:
+       case OP_MINUPTOI:
+       case OP_POSUPTOI:
+       case OP_NOTUPTOI:
+       case OP_NOTMINUPTOI:
+       case OP_NOTPOSUPTOI:
+       caseless = TRUE;
+       codevalue -= OP_STARI - OP_STAR;
+       /* Fall through */
        case OP_UPTO:
        case OP_MINUPTO:
        case OP_POSUPTO:
-Line 2027 
 for (;;)
+Line 2376 
 for (;;)
        if (clen > 0)
          {
          unsigned int otherd = NOTACHAR;
-         if ((ims & PCRE_CASELESS) != 0)
+         if (caseless)
            {
  #ifdef SUPPORT_UTF8
            if (utf8 && d >= 128)
              {
  #ifdef SUPPORT_UCP
-             otherd = _pcre_ucp_othercase(d);
+             otherd = UCD_OTHERCASE(d);
  #endif  /* SUPPORT_UCP */
              }
            else
-Line 2094 
 for (;;)
+Line 2443 
 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 2141 
 for (;;)
+Line 2490 
 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 2159 
 for (;;)
+Line 2514 
 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 */
            sizeof(local_workspace)/sizeof(int),  /* size of same */
-           ims,                                  /* the current ims flags */
            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 2179 
 for (;;)
+Line 2534 
 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 2218 
 for (;;)
+Line 2604 
 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 */
              sizeof(local_workspace)/sizeof(int),  /* size of same */
-             ims,                                  /* the current ims flags */
              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 2250 
 for (;;)
+Line 2636 
 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 */
            sizeof(local_workspace)/sizeof(int),  /* size of same */
-           ims,                                  /* the current ims flags */
            rlevel,                               /* function recursion level */
            recursing + 1);                       /* regex recurse level */
-Line 2293 
 for (;;)
+Line 2678 
 for (;;)
        break;
        /*-----------------------------------------------------------------*/
+       case OP_BRAPOS:
+       case OP_SBRAPOS:
+       case OP_CBRAPOS:
+       case OP_SCBRAPOS:
+       case OP_BRAPOSZERO:
+         {
+         int charcount, matched_count;
+         const uschar *local_ptr = ptr;
+         BOOL allow_zero;
+         if (codevalue == OP_BRAPOSZERO)
+           {
+           allow_zero = TRUE;
+           codevalue = *(++code);  /* Codevalue will be one of above BRAs */
+           }
+         else allow_zero = FALSE;
+         /* Loop to match the subpattern as many times as possible as if it were
+         a complete pattern. */
+         for (matched_count = 0;; matched_count++)
+           {
+           int local_offsets[2];
+           int local_workspace[1000];
+           int rc = internal_dfa_exec(
+             md,                                   /* fixed match data */
+             code,                                 /* this subexpression's code */
+             local_ptr,                            /* where we currently are */
+             (int)(ptr - start_subject),           /* start offset */
+             local_offsets,                        /* offset vector */
+             sizeof(local_offsets)/sizeof(int),    /* size of same */
+             local_workspace,                      /* workspace vector */
+             sizeof(local_workspace)/sizeof(int),  /* size of same */
+             rlevel,                               /* function recursion level */
+             recursing);                           /* pass on regex recursion */
+           /* Failed to match */
+           if (rc < 0)
+             {
+             if (rc != PCRE_ERROR_NOMATCH) return rc;
+             break;
+             }
+           /* Matched: break the loop if zero characters matched. */
+           charcount = local_offsets[1] - local_offsets[0];
+           if (charcount == 0) break;
+           local_ptr += charcount;    /* Advance temporary position ptr */
+           }
+         /* At this point we have matched the subpattern matched_count
+         times, and local_ptr is pointing to the character after the end of the
+         last match. */
+         if (matched_count > 0 || allow_zero)
+           {
+           const uschar *end_subpattern = code;
+           int next_state_offset;
+           do { end_subpattern += GET(end_subpattern, 1); }
+             while (*end_subpattern == OP_ALT);
+           next_state_offset =
+             (int)(end_subpattern - start_code + LINK_SIZE + 1);
+           /* Optimization: if there are no more active states, and there
+           are no new states yet set up, then skip over the subject string
+           right here, to save looping. Otherwise, set up the new state to swing
+           into action when the end of the matched substring is reached. */
+           if (i + 1 >= active_count && new_count == 0)
+             {
+             ptr = local_ptr;
+             clen = 0;
+             ADD_NEW(next_state_offset, 0);
+             }
+           else
+             {
+             const uschar *p = ptr;
+             const uschar *pp = local_ptr;
+             charcount = pp - p;
+             while (p < pp) if ((*p++ & 0xc0) == 0x80) charcount--;
+             ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
+             }
+           }
+         }
+       break;
+       /*-----------------------------------------------------------------*/
        case OP_ONCE:
          {
          int local_offsets[2];
-Line 2302 
 for (;;)
+Line 2777 
 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 */
            sizeof(local_workspace)/sizeof(int),  /* size of same */
-           ims,                                  /* the current ims flags */
            rlevel,                               /* function recursion level */
            recursing);                           /* pass on regex recursion */
-Line 2319 
 for (;;)
+Line 2793 
 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 2327 
 for (;;)
+Line 2802 
 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 2342 
 for (;;)
+Line 2817 
 for (;;)
            /* Optimization: if there are no more active states, and there
            are no new states yet set up, then skip over the subject string
            right here, to save looping. Otherwise, set up the new state to swing
-           into action when the end of the substring is reached. */
+           into action when the end of the matched substring is reached. */
            else if (i + 1 >= active_count && new_count == 0)
              {
-Line 2372 
 for (;;)
+Line 2847 
 for (;;)
              if (repeat_state_offset >= 0)
                { ADD_NEW_DATA(-repeat_state_offset, 0, (charcount - 1)); }
              }
            }
          else if (rc != PCRE_ERROR_NOMATCH) return rc;
          }
-Line 2383 
 for (;;)
+Line 2857 
 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 2417 
 for (;;)
+Line 2892 
 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 2484 
 Returns:          > 0 => number of match
+Line 2973 
 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 2515 
 if (re == NULL || subject == NULL || wor
+Line 3004 
 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 2571 
 md->start_code = (const uschar *)argumen
+Line 3061 
 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 2581 
 switch ((((options & PCRE_NEWLINE_BITS)
+Line 3084 
 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 2620 
 back the character offset. */
+Line 3123 
 back the character offset. */
  #ifdef SUPPORT_UTF8
  if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
    {
-   if (_pcre_valid_utf8((uschar *)subject, length) >= 0)
+   int erroroffset;
-     return PCRE_ERROR_BADUTF8;
+   int errorcode = _pcre_valid_utf8((uschar *)subject, length, &erroroffset);
-   if (start_offset > 0 && start_offset < length)
+   if (errorcode != 0)
      {
-     int tb = ((uschar *)subject)[start_offset];
+     if (offsetcount >= 2)
-     if (tb > 127)
        {
-       tb &= 0xc0;
+       offsets[0] = erroroffset;
-       if (tb != 0 && tb != 0xc0) return PCRE_ERROR_BADUTF8_OFFSET;
+       offsets[1] = errorcode;
        }
-     }
+     return (errorcode <= PCRE_UTF8_ERR5 && (options & PCRE_PARTIAL_HARD) != 0)?
+       PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
+     }
+   if (start_offset > 0 && start_offset < length &&
+         (((USPTR)subject)[start_offset] & 0xc0) == 0x80)
+     return PCRE_ERROR_BADUTF8_OFFSET;
    }
  #endif
-Line 2644 
 if (md->tables == NULL) md->tables = _pc
+Line 3151 
 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 2655 
 studied, there may be a bitmap of possib
+Line 3162 
 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 2663 
 if (!anchored)
+Line 3170 
 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 2672 
 if (!anchored)
+Line 3179 
 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 2680 
 if ((re->options & PCRE_REQCHSET) != 0)
+Line 3187 
 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 2692 
 for (;;)
+Line 3198 
 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
+           ANYCRLF, and we are now at a LF, advance the match position by one
+           more character. */
-         /* If we have just passed a CR and the newline option is ANY or
+           if (current_subject[-1] == CHAR_CR &&
-         ANYCRLF, and we are now at a LF, advance the match position by one more
+                (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
-         character. */
+                current_subject < end_subject &&
+                *current_subject == CHAR_NL)
-         if (current_subject[-1] == '\r' &&
+             current_subject++;
-              (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
+           }
-              current_subject < end_subject &&
-              *current_subject == '\n')
-           current_subject++;
          }
-       }
-     /* Or to a non-unique first char after study */
+       /* 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 2821 
 for (;;)
+Line 3385 
 for (;;)
      offsetcount,                       /* size of same */
      workspace,                         /* workspace vector */
      wscount,                           /* size of same */
-     re->options & (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL), /* ims flags */
 ,                                 /* function recurse level */
 );                                /* regex recurse level */
-Line 2842 
 for (;;)
+Line 3405 
 for (;;)
      }
    if (current_subject > end_subject) break;
    /* If we have just passed a CR and we are now at a LF, and the pattern does
    not contain any explicit matches for \r or \n, and the newline option is CRLF
    or ANY or ANYCRLF, advance the match position by one more character. */
-   if (current_subject[-1] == '\r' &&
+   if (current_subject[-1] == CHAR_CR &&
        current_subject < end_subject &&
-       *current_subject == '\n' &&
+       *current_subject == CHAR_NL &&
-       (re->options & PCRE_HASCRORLF) == 0 &&
+       (re->flags & PCRE_HASCRORLF) == 0 &&
          (md->nltype == NLTYPE_ANY ||
           md->nltype == NLTYPE_ANYCRLF ||
           md->nllen == 2))

 Legend:



Removed from v.226
 


changed lines


 
Added in v.606
 Legend:



Removed from v.226
 


changed lines


 
Added in v.606
-Removed from v.226
+Added in v.606

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12