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

Diff of /code/trunk/pcre_dfa_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 97 by ph10,
Mon Mar  5 12:36:47 2007 UTC
+revision 613 by ph10,
Sat Jul  2 16:59:52 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-2006 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"
+ #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. */
+ 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 100
+ #define OP_PROP_EXTRA       300
- #define OP_EXTUNI_EXTRA 120
+ #define OP_EXTUNI_EXTRA     320
- #define OP_ANYNL_EXTRA 140
+ #define OP_ANYNL_EXTRA      340
+ #define OP_HSPACE_EXTRA     360
+ #define OP_VSPACE_EXTRA     380
  /* 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. */
+ small value. Non-zero values in the table are the offsets from the opcode where
+ 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, 0, 0, 0, 0, 0,  /* \A, \G, \B, \b, \D, \d, \S, \s, \W, \w */
+, 0, 0, 0, 0,                 /* \A, \G, \K, \B, \b                     */
-, 0,                          /* Any, Anybyte                           */
+, 0, 0, 0, 0, 0,              /* \D, \d, \S, \s, \W, \w                 */
-, 0, 0, 0,                    /* NOTPROP, PROP, EXTUNI, ANYNL           */
+, 0, 0,                       /* Any, AllAny, Anybyte                   */
-, 0, 0, 0, 0,                 /* \Z, \z, Opt, ^, $                      */
+, 0,                          /* \P, \p                                 */
+, 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */
+,                             /* \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 104 
 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, 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,                    /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT    */
+, 0                           /* 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,                    /* 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,                       /* MARK, PRUNE, PRUNE_ARG                 */
+, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG         */
+, 0, 0, 0,                    /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT    */
+, 0                           /* 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, 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, 0, 0, 0, 0,
    ctype_digit, 0,
    ctype_space, 0,
    ctype_word,  0,
-                              /* OP_ANY */
+, 1                            /* OP_ANY, OP_ALLANY */
  };
-Line 151 
 these structures in, is a vector of ints
+Line 272 
 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 207 
 Arguments:
+Line 327 
 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 224 
 for the current character, one for the f
+Line 343 
 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 235 
 for the current character, one for the f
+Line 353 
 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 247 
 for the current character, one for the f
+Line 364 
 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 258 
 for the current character, one for the f
+Line 374 
 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 277 
 internal_dfa_exec(
+Line 392 
 internal_dfa_exec(
    int offsetcount,
    int *workspace,
    int wscount,
-   int ims,
    int  rlevel,
    int  recursing)
  {
-Line 325 
 next_new_state = new_states = active_sta
+Line 439 
 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 374 
 if (*first_op == OP_REVERSE)
+Line 489 
 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 386 
 if (*first_op == OP_REVERSE)
+Line 506 
 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 419 
 else
+Line 539 
 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 442 
 for (;;)
+Line 564 
 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 455 
 for (;;)
+Line 579 
 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 497 
 for (;;)
+Line 621 
 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;
-     int chartype, script;
- #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 532 
 for (;;)
+Line 652 
 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 549 
 for (;;)
+Line 671 
 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
      permitted.
      We also use this mechanism for opcodes such as OP_TYPEPLUS that take an
-     argument that is not a data character - but is always one byte long.
+     argument that is not a data character - but is always one byte long. We
-     Unfortunately, we have to take special action to deal with  \P, \p, and
+     have to take special action to deal with  \P, \p, \H, \h, \V, \v and \X in
-     \X in this case. To keep the other cases fast, convert these ones to new
+     this case. To keep the other cases fast, convert these ones to new opcodes.
-     opcodes. */
+     */
      if (coptable[codevalue] > 0)
        {
-Line 576 
 for (;;)
+Line 704 
 for (;;)
            case OP_PROP: codevalue += OP_PROP_EXTRA; break;
            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 591 
 for (;;)
+Line 723 
 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 609 
 for (;;)
+Line 760 
 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 640 
 for (;;)
+Line 797 
 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 648 
 for (;;)
+Line 805 
 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 657 
 for (;;)
+Line 814 
 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 672 
 for (;;)
+Line 829 
 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 714 
 for (;;)
+Line 881 
 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 728 
 for (;;)
+Line 903 
 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 766 
 for (;;)
+Line 955 
 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 783 
 for (;;)
+Line 998 
 for (;;)
        break;
- #ifdef SUPPORT_UCP
        /*-----------------------------------------------------------------*/
        /* Check the next character by Unicode property. We will get here only
        if the support is in the binary; otherwise a compile-time error occurs.
        */
+ #ifdef SUPPORT_UCP
        case OP_PROP:
        case OP_NOTPROP:
        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 803 
 for (;;)
+Line 1017 
 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 835 
 for (;;)
+Line 1074 
 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 847 
 for (;;)
+Line 1086 
 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 873 
 for (;;)
+Line 1109 
 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 898 
 for (;;)
+Line 1131 
 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 921 
 for (;;)
+Line 1151 
 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 945 
 for (;;)
+Line 1172 
 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 970 
 for (;;)
+Line 1194 
 for (;;)
        argument. It keeps the code above fast for the other cases. The argument
        is in the d variable. */
+ #ifdef SUPPORT_UCP
        case OP_PROP_EXTRA + OP_TYPEPLUS:
        case OP_PROP_EXTRA + OP_TYPEMINPLUS:
        case OP_PROP_EXTRA + OP_TYPEPOSPLUS:
-Line 978 
 for (;;)
+Line 1203 
 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 986 
 for (;;)
+Line 1211 
 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 1027 
 for (;;)
+Line 1277 
 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 1041 
 for (;;)
+Line 1291 
 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 1049 
 for (;;)
+Line 1299 
 for (;;)
          ADD_NEW_DATA(-state_offset, count, ncount);
          }
        break;
+ #endif
        /*-----------------------------------------------------------------*/
        case OP_ANYNL_EXTRA + OP_TYPEPLUS:
-Line 1061 
 for (;;)
+Line 1312 
 for (;;)
          int ncount = 0;
          switch (c)
            {
+           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 */
+             next_active_state--;
+             }
+           count++;
+           ADD_NEW_DATA(-state_offset, count, ncount);
+           break;
+           default:
+           break;
+           }
+         }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_VSPACE_EXTRA + OP_TYPEPLUS:
+       case OP_VSPACE_EXTRA + OP_TYPEMINPLUS:
+       case OP_VSPACE_EXTRA + OP_TYPEPOSPLUS:
+       count = current_state->count;  /* Already matched */
+       if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
+       if (clen > 0)
+         {
+         BOOL OK;
+         switch (c)
+           {
            case 0x000a:
            case 0x000b:
            case 0x000c:
+           case 0x000d:
            case 0x0085:
            case 0x2028:
            case 0x2029:
-           if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)
+           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 */
              next_active_state--;
              }
            count++;
-           ADD_NEW_DATA(-state_offset, count, ncount);
+           ADD_NEW_DATA(-state_offset, count, 0);
+           }
+         }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_HSPACE_EXTRA + OP_TYPEPLUS:
+       case OP_HSPACE_EXTRA + OP_TYPEMINPLUS:
+       case OP_HSPACE_EXTRA + OP_TYPEPOSPLUS:
+       count = current_state->count;  /* Already matched */
+       if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
+       if (clen > 0)
+         {
+         BOOL OK;
+         switch (c)
+           {
+           case 0x09:      /* HT */
+           case 0x20:      /* SPACE */
+           case 0xa0:      /* NBSP */
+           case 0x1680:    /* OGHAM SPACE MARK */
+           case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
+           case 0x2000:    /* EN QUAD */
+           case 0x2001:    /* EM QUAD */
+           case 0x2002:    /* EN SPACE */
+           case 0x2003:    /* EM SPACE */
+           case 0x2004:    /* THREE-PER-EM SPACE */
+           case 0x2005:    /* FOUR-PER-EM SPACE */
+           case 0x2006:    /* SIX-PER-EM SPACE */
+           case 0x2007:    /* FIGURE SPACE */
+           case 0x2008:    /* PUNCTUATION SPACE */
+           case 0x2009:    /* THIN SPACE */
+           case 0x200A:    /* HAIR SPACE */
+           case 0x202f:    /* NARROW NO-BREAK SPACE */
+           case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
+           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 */
+             next_active_state--;
+             }
+           count++;
+           ADD_NEW_DATA(-state_offset, count, 0);
+           }
          }
        break;
        /*-----------------------------------------------------------------*/
+ #ifdef SUPPORT_UCP
        case OP_PROP_EXTRA + OP_TYPEQUERY:
        case OP_PROP_EXTRA + OP_TYPEMINQUERY:
        case OP_PROP_EXTRA + OP_TYPEPOSQUERY:
-Line 1102 
 for (;;)
+Line 1450 
 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 1110 
 for (;;)
+Line 1458 
 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 1160 
 for (;;)
+Line 1533 
 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 1175 
 for (;;)
+Line 1548 
 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;
            }
          ADD_NEW_DATA(-(state_offset + count), 0, ncount);
          }
        break;
+ #endif
        /*-----------------------------------------------------------------*/
        case OP_ANYNL_EXTRA + OP_TYPEQUERY:
-Line 1202 
 for (;;)
+Line 1576 
 for (;;)
          int ncount = 0;
          switch (c)
            {
+           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)
+             {
+             active_count--;           /* Remove non-match possibility */
+             next_active_state--;
+             }
+           ADD_NEW_DATA(-(state_offset + count), 0, ncount);
+           break;
+           default:
+           break;
+           }
+         }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_VSPACE_EXTRA + OP_TYPEQUERY:
+       case OP_VSPACE_EXTRA + OP_TYPEMINQUERY:
+       case OP_VSPACE_EXTRA + OP_TYPEPOSQUERY:
+       count = 2;
+       goto QS4;
+       case OP_VSPACE_EXTRA + OP_TYPESTAR:
+       case OP_VSPACE_EXTRA + OP_TYPEMINSTAR:
+       case OP_VSPACE_EXTRA + OP_TYPEPOSSTAR:
+       count = 0;
+       QS4:
+       ADD_ACTIVE(state_offset + 2, 0);
+       if (clen > 0)
+         {
+         BOOL OK;
+         switch (c)
+           {
            case 0x000a:
            case 0x000b:
            case 0x000c:
+           case 0x000d:
            case 0x0085:
            case 0x2028:
            case 0x2029:
-           if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||
+           OK = TRUE;
-               codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)
+           break;
+           default:
+           OK = FALSE;
+           break;
+           }
+         if (OK == (d == OP_VSPACE))
+           {
+           if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSSTAR ||
+               codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSQUERY)
              {
              active_count--;           /* Remove non-match possibility */
              next_active_state--;
              }
-           ADD_NEW_DATA(-(state_offset + count), 0, ncount);
+           ADD_NEW_DATA(-(state_offset + count), 0, 0);
+           }
+         }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_HSPACE_EXTRA + OP_TYPEQUERY:
+       case OP_HSPACE_EXTRA + OP_TYPEMINQUERY:
+       case OP_HSPACE_EXTRA + OP_TYPEPOSQUERY:
+       count = 2;
+       goto QS5;
+       case OP_HSPACE_EXTRA + OP_TYPESTAR:
+       case OP_HSPACE_EXTRA + OP_TYPEMINSTAR:
+       case OP_HSPACE_EXTRA + OP_TYPEPOSSTAR:
+       count = 0;
+       QS5:
+       ADD_ACTIVE(state_offset + 2, 0);
+       if (clen > 0)
+         {
+         BOOL OK;
+         switch (c)
+           {
+           case 0x09:      /* HT */
+           case 0x20:      /* SPACE */
+           case 0xa0:      /* NBSP */
+           case 0x1680:    /* OGHAM SPACE MARK */
+           case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
+           case 0x2000:    /* EN QUAD */
+           case 0x2001:    /* EM QUAD */
+           case 0x2002:    /* EN SPACE */
+           case 0x2003:    /* EM SPACE */
+           case 0x2004:    /* THREE-PER-EM SPACE */
+           case 0x2005:    /* FOUR-PER-EM SPACE */
+           case 0x2006:    /* SIX-PER-EM SPACE */
+           case 0x2007:    /* FIGURE SPACE */
+           case 0x2008:    /* PUNCTUATION SPACE */
+           case 0x2009:    /* THIN SPACE */
+           case 0x200A:    /* HAIR SPACE */
+           case 0x202f:    /* NARROW NO-BREAK SPACE */
+           case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
+           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)
+             {
+             active_count--;           /* Remove non-match possibility */
+             next_active_state--;
+             }
+           ADD_NEW_DATA(-(state_offset + count), 0, 0);
+           }
          }
        break;
        /*-----------------------------------------------------------------*/
+ #ifdef SUPPORT_UCP
        case OP_PROP_EXTRA + OP_TYPEEXACT:
        case OP_PROP_EXTRA + OP_TYPEUPTO:
        case OP_PROP_EXTRA + OP_TYPEMINUPTO:
-Line 1236 
 for (;;)
+Line 1722 
 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 1244 
 for (;;)
+Line 1730 
 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 1289 
 for (;;)
+Line 1800 
 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 1303 
 for (;;)
+Line 1814 
 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 1824 
 for (;;)
            { ADD_NEW_DATA(-state_offset, count, ncount); }
          }
        break;
+ #endif
        /*-----------------------------------------------------------------*/
        case OP_ANYNL_EXTRA + OP_TYPEEXACT:
-Line 1327 
 for (;;)
+Line 1839 
 for (;;)
          int ncount = 0;
          switch (c)
            {
+           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 */
+             next_active_state--;
+             }
+           if (++count >= GET2(code, 1))
+             { ADD_NEW_DATA(-(state_offset + 4), 0, ncount); }
+           else
+             { ADD_NEW_DATA(-state_offset, count, ncount); }
+           break;
+           default:
+           break;
+           }
+         }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_VSPACE_EXTRA + OP_TYPEEXACT:
+       case OP_VSPACE_EXTRA + OP_TYPEUPTO:
+       case OP_VSPACE_EXTRA + OP_TYPEMINUPTO:
+       case OP_VSPACE_EXTRA + OP_TYPEPOSUPTO:
+       if (codevalue != OP_VSPACE_EXTRA + OP_TYPEEXACT)
+         { ADD_ACTIVE(state_offset + 4, 0); }
+       count = current_state->count;  /* Number already matched */
+       if (clen > 0)
+         {
+         BOOL OK;
+         switch (c)
+           {
            case 0x000a:
            case 0x000b:
            case 0x000c:
+           case 0x000d:
            case 0x0085:
            case 0x2028:
            case 0x2029:
-           if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)
+           OK = TRUE;
+           break;
+           default:
+           OK = FALSE;
+           }
+         if (OK == (d == OP_VSPACE))
+           {
+           if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSUPTO)
              {
              active_count--;           /* Remove non-match possibility */
              next_active_state--;
              }
            if (++count >= GET2(code, 1))
-             { ADD_NEW_DATA(-(state_offset + 4), 0, ncount); }
+             { ADD_NEW_DATA(-(state_offset + 4), 0, 0); }
            else
-             { ADD_NEW_DATA(-state_offset, count, ncount); }
+             { ADD_NEW_DATA(-state_offset, count, 0); }
+           }
+         }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_HSPACE_EXTRA + OP_TYPEEXACT:
+       case OP_HSPACE_EXTRA + OP_TYPEUPTO:
+       case OP_HSPACE_EXTRA + OP_TYPEMINUPTO:
+       case OP_HSPACE_EXTRA + OP_TYPEPOSUPTO:
+       if (codevalue != OP_HSPACE_EXTRA + OP_TYPEEXACT)
+         { ADD_ACTIVE(state_offset + 4, 0); }
+       count = current_state->count;  /* Number already matched */
+       if (clen > 0)
+         {
+         BOOL OK;
+         switch (c)
+           {
+           case 0x09:      /* HT */
+           case 0x20:      /* SPACE */
+           case 0xa0:      /* NBSP */
+           case 0x1680:    /* OGHAM SPACE MARK */
+           case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
+           case 0x2000:    /* EN QUAD */
+           case 0x2001:    /* EM QUAD */
+           case 0x2002:    /* EN SPACE */
+           case 0x2003:    /* EM SPACE */
+           case 0x2004:    /* THREE-PER-EM SPACE */
+           case 0x2005:    /* FOUR-PER-EM SPACE */
+           case 0x2006:    /* SIX-PER-EM SPACE */
+           case 0x2007:    /* FIGURE SPACE */
+           case 0x2008:    /* PUNCTUATION SPACE */
+           case 0x2009:    /* THIN SPACE */
+           case 0x200A:    /* HAIR SPACE */
+           case 0x202f:    /* NARROW NO-BREAK SPACE */
+           case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
+           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 */
+             next_active_state--;
+             }
+           if (++count >= GET2(code, 1))
+             { ADD_NEW_DATA(-(state_offset + 4), 0, 0); }
+           else
+             { ADD_NEW_DATA(-state_offset, count, 0); }
+           }
          }
        break;
-Line 1364 
 for (;;)
+Line 1979 
 for (;;)
        break;
        /*-----------------------------------------------------------------*/
-       case OP_CHARNC:
+       case OP_CHARI:
        if (clen == 0) break;
  #ifdef SUPPORT_UTF8
-Line 1379 
 for (;;)
+Line 1994 
 for (;;)
            other case of the character. */
  #ifdef SUPPORT_UCP
-           othercase = _pcre_ucp_othercase(c);
+           othercase = UCD_OTHERCASE(c);
  #else
            othercase = NOTACHAR;
  #endif
-Line 1404 
 for (;;)
+Line 2019 
 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 1412 
 for (;;)
+Line 2027 
 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 1429 
 for (;;)
+Line 2044 
 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 1451 
 for (;;)
+Line 2069 
 for (;;)
        break;
        /*-----------------------------------------------------------------*/
-       /* Match a negated single character. This is only used for one-byte
+       case OP_NOT_VSPACE:
-       characters, that is, we know that d < 256. The character we are
+       if (clen > 0) switch(c)
-       checking (c) can be multibyte. */
+         {
+         case 0x000a:
+         case 0x000b:
+         case 0x000c:
+         case 0x000d:
+         case 0x0085:
+         case 0x2028:
+         case 0x2029:
+         break;
-       case OP_NOT:
+         default:
-       if (clen > 0)
+         ADD_NEW(state_offset + 1, 0);
+         break;
+         }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_VSPACE:
+       if (clen > 0) switch(c)
+         {
+         case 0x000a:
+         case 0x000b:
+         case 0x000c:
+         case 0x000d:
+         case 0x0085:
+         case 0x2028:
+         case 0x2029:
+         ADD_NEW(state_offset + 1, 0);
+         break;
+         default: break;
+         }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_NOT_HSPACE:
+       if (clen > 0) switch(c)
+         {
+         case 0x09:      /* HT */
+         case 0x20:      /* SPACE */
+         case 0xa0:      /* NBSP */
+         case 0x1680:    /* OGHAM SPACE MARK */
+         case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
+         case 0x2000:    /* EN QUAD */
+         case 0x2001:    /* EM QUAD */
+         case 0x2002:    /* EN SPACE */
+         case 0x2003:    /* EM SPACE */
+         case 0x2004:    /* THREE-PER-EM SPACE */
+         case 0x2005:    /* FOUR-PER-EM SPACE */
+         case 0x2006:    /* SIX-PER-EM SPACE */
+         case 0x2007:    /* FIGURE SPACE */
+         case 0x2008:    /* PUNCTUATION SPACE */
+         case 0x2009:    /* THIN SPACE */
+         case 0x200A:    /* HAIR SPACE */
+         case 0x202f:    /* NARROW NO-BREAK SPACE */
+         case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
+         case 0x3000:    /* IDEOGRAPHIC SPACE */
+         break;
+         default:
+         ADD_NEW(state_offset + 1, 0);
+         break;
+         }
+       break;
+       /*-----------------------------------------------------------------*/
+       case OP_HSPACE:
+       if (clen > 0) switch(c)
          {
-         unsigned int otherd = ((ims & PCRE_CASELESS) != 0)? fcc[d] : d;
+         case 0x09:      /* HT */
-         if (c != d && c != otherd) { ADD_NEW(state_offset + dlen + 1, 0); }
+         case 0x20:      /* SPACE */
+         case 0xa0:      /* NBSP */
+         case 0x1680:    /* OGHAM SPACE MARK */
+         case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
+         case 0x2000:    /* EN QUAD */
+         case 0x2001:    /* EM QUAD */
+         case 0x2002:    /* EN SPACE */
+         case 0x2003:    /* EM SPACE */
+         case 0x2004:    /* THREE-PER-EM SPACE */
+         case 0x2005:    /* FOUR-PER-EM SPACE */
+         case 0x2006:    /* SIX-PER-EM SPACE */
+         case 0x2007:    /* FIGURE SPACE */
+         case 0x2008:    /* PUNCTUATION SPACE */
+         case 0x2009:    /* THIN SPACE */
+         case 0x200A:    /* HAIR SPACE */
+         case 0x202f:    /* NARROW NO-BREAK SPACE */
+         case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
+         case 0x3000:    /* IDEOGRAPHIC SPACE */
+         ADD_NEW(state_offset + 1, 0);
+         break;
          }
        break;
        /*-----------------------------------------------------------------*/
+       /* Match a negated single character casefully. 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_NOT:
+       if (clen > 0 && c != d) { 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 1475 
 for (;;)
+Line 2205 
 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 1503 
 for (;;)
+Line 2233 
 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 1513 
 for (;;)
+Line 2252 
 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 1539 
 for (;;)
+Line 2278 
 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 1549 
 for (;;)
+Line 2297 
 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 1575 
 for (;;)
+Line 2323 
 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 1605 
 for (;;)
+Line 2358 
 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 1616 
 for (;;)
+Line 2378 
 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 1683 
 for (;;)
+Line 2445 
 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 1730 
 for (;;)
+Line 2492 
 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 1748 
 for (;;)
+Line 2516 
 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 1768 
 for (;;)
+Line 2536 
 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 1807 
 for (;;)
+Line 2606 
 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 1839 
 for (;;)
+Line 2638 
 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 1882 
 for (;;)
+Line 2680 
 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 1891 
 for (;;)
+Line 2779 
 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 1908 
 for (;;)
+Line 2795 
 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 1916 
 for (;;)
+Line 2804 
 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 1931 
 for (;;)
+Line 2819 
 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 1961 
 for (;;)
+Line 2849 
 for (;;)
              if (repeat_state_offset >= 0)
                { ADD_NEW_DATA(-repeat_state_offset, 0, (charcount - 1)); }
              }
            }
          else if (rc != PCRE_ERROR_NOMATCH) return rc;
          }
-Line 1972 
 for (;;)
+Line 2859 
 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 2006 
 for (;;)
+Line 2894 
 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 2073 
 Returns:          > 0 => number of match
+Line 2975 
 Returns:          > 0 => number of match
                   < -1 => some kind of unexpected problem
  */
- PCRE_DATA_SCOPE 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 2104 
 if (re == NULL || subject == NULL || wor
+Line 3006 
 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 2160 
 md->start_code = (const uschar *)argumen
+Line 3063 
 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. */
- switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : options) &
+ switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &
           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;
    }
- if (newline < 0)
+ if (newline == -2)
+   {
+   md->nltype = NLTYPE_ANYCRLF;
+   }
+ else if (newline < 0)
    {
    md->nltype = NLTYPE_ANY;
    }
-Line 2204 
 back the character offset. */
+Line 3125 
 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 2228 
 if (md->tables == NULL) md->tables = _pc
+Line 3153 
 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 2239 
 studied, there may be a bitmap of possib
+Line 3164 
 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 2247 
 if (!anchored)
+Line 3172 
 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 2256 
 if (!anchored)
+Line 3181 
 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 2264 
 if ((re->options & PCRE_REQCHSET) != 0)
+Line 3189 
 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 2276 
 for (;;)
+Line 3200 
 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 (current_subject[-1] == CHAR_CR &&
+                (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
+                current_subject < end_subject &&
+                *current_subject == CHAR_NL)
+             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 2395 
 for (;;)
+Line 3387 
 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 2416 
 for (;;)
+Line 3407 
 for (;;)
      }
    if (current_subject > end_subject) break;
-   /* If we have just passed a CR and the newline option is CRLF or ANY, and we
+   /* If we have just passed a CR and we are now at a LF, and the pattern does
-   are now at a LF, advance the match position by one more character. */
+   not contain any explicit matches for \r or \n, and the newline option is CRLF
+   or ANY or ANYCRLF, advance the match position by one more character. */
-   if (current_subject[-1] == '\r' &&
-        (md->nltype == NLTYPE_ANY || md->nllen == 2) &&
+   if (current_subject[-1] == CHAR_CR &&
-        current_subject < end_subject &&
+       current_subject < end_subject &&
-        *current_subject == '\n')
+       *current_subject == CHAR_NL &&
+       (re->flags & PCRE_HASCRORLF) == 0 &&
+         (md->nltype == NLTYPE_ANY ||
+          md->nltype == NLTYPE_ANYCRLF ||
+          md->nllen == 2))
      current_subject++;
    }   /* "Bumpalong" loop */

 Legend:



Removed from v.97
 


changed lines


 
Added in v.613
 Legend:



Removed from v.97
 


changed lines


 
Added in v.613
-Removed from v.97
+Added in v.613

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12