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

Diff of /code/trunk/pcre_exec.c

Parent Directory | Revision Log | View Patch Patch

-revision 96 by nigel,
Fri Mar  2 13:10:43 2007 UTC
+revision 298 by ph10,
Thu Jan 10 17:09:12 2008 UTC
 Line 6
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2006 University of Cambridge
+            Copyright (c) 1997-2007 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 42 
 POSSIBILITY OF SUCH DAMAGE.
  pattern matching using an NFA algorithm, trying to mimic Perl as closely as
  possible. There are also some static supporting functions. */
+ #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 */
  #include "pcre_internal.h"
- /* The chain of eptrblocks for tail recursions uses memory in stack workspace,
+ /* Undefine some potentially clashing cpp symbols */
- obtained at top level, the size of which is defined by EPTR_WORK_SIZE. */
- #define EPTR_WORK_SIZE (1000)
+ #undef min
+ #undef max
  /* Flag bits for the match() function */
  #define match_condassert     0x01  /* Called to check a condition assertion */
  #define match_cbegroup       0x02  /* Could-be-empty unlimited repeat group */
- #define match_tail_recursed  0x04  /* Tail recursive call */
  /* Non-error returns from the match() function. Error returns are externally
  defined PCRE_ERROR_xxx codes, which are all negative. */
-Line 65 
 defined PCRE_ERROR_xxx codes, which are
+Line 68 
 defined PCRE_ERROR_xxx codes, which are
  #define MATCH_MATCH        1
  #define MATCH_NOMATCH      0
+ /* Special internal returns from the match() function. Make them sufficiently
+ negative to avoid the external error codes. */
+ #define MATCH_COMMIT       (-999)
+ #define MATCH_PRUNE        (-998)
+ #define MATCH_SKIP         (-997)
+ #define MATCH_THEN         (-996)
  /* Maximum number of ints of offset to save on the stack for recursive calls.
  If the offset vector is bigger, malloc is used. This should be a multiple of 3,
  because the offset vector is always a multiple of 3 long. */
-Line 183 
 calls by keeping local variables that ne
+Line 194 
 calls by keeping local variables that ne
  obtained from malloc() instead instead of on the stack. Macros are used to
  achieve this so that the actual code doesn't look very different to what it
  always used to.
+ The original heap-recursive code used longjmp(). However, it seems that this
+ can be very slow on some operating systems. Following a suggestion from Stan
+ Switzer, the use of longjmp() has been abolished, at the cost of having to
+ provide a unique number for each call to RMATCH. There is no way of generating
+ a sequence of numbers at compile time in C. I have given them names, to make
+ them stand out more clearly.
+ Crude tests on x86 Linux show a small speedup of around 5-8%. However, on
+ FreeBSD, avoiding longjmp() more than halves the time taken to run the standard
+ tests. Furthermore, not using longjmp() means that local dynamic variables
+ don't have indeterminate values; this has meant that the frame size can be
+ reduced because the result can be "passed back" by straight setting of the
+ variable instead of being passed in the frame.
  ****************************************************************************
  ***************************************************************************/
+ /* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
+ below must be updated in sync.  */
+ enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,
+        RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
+        RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
+        RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
+        RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
+        RM51,  RM52, RM53, RM54 };
  /* These versions of the macros use the stack, as normal. There are debugging
- versions and production versions. */
+ versions and production versions. Note that the "rw" argument of RMATCH isn't
+ actuall used in this definition. */
  #ifndef NO_RECURSE
  #define REGISTER register
  #ifdef DEBUG
- #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg) \
+ #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
    { \
    printf("match() called in line %d\n", __LINE__); \
-   rx = match(ra,rb,rc,rd,re,rf,rg,rdepth+1); \
+   rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1); \
    printf("to line %d\n", __LINE__); \
    }
  #define RRETURN(ra) \
-Line 205 
 versions and production versions. */
+Line 241 
 versions and production versions. */
    return ra; \
    }
  #else
- #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg) \
+ #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
-   rx = match(ra,rb,rc,rd,re,rf,rg,rdepth+1)
+   rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1)
  #define RRETURN(ra) return ra
  #endif
  #else
- /* These versions of the macros manage a private stack on the heap. Note
+ /* These versions of the macros manage a private stack on the heap. Note that
- that the rd argument of RMATCH isn't actually used. It's the md argument of
+ the "rd" argument of RMATCH isn't actually used in this definition. It's the md
- match(), which never changes. */
+ argument of match(), which never changes. */
  #define REGISTER
- #define RMATCH(rx,ra,rb,rc,rd,re,rf,rg)\
+ #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
    {\
    heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
-   if (setjmp(frame->Xwhere) == 0)\
+   frame->Xwhere = rw; \
-     {\
+   newframe->Xeptr = ra;\
-     newframe->Xeptr = ra;\
+   newframe->Xecode = rb;\
-     newframe->Xecode = rb;\
+   newframe->Xmstart = mstart;\
-     newframe->Xoffset_top = rc;\
+   newframe->Xoffset_top = rc;\
-     newframe->Xims = re;\
+   newframe->Xims = re;\
-     newframe->Xeptrb = rf;\
+   newframe->Xeptrb = rf;\
-     newframe->Xflags = rg;\
+   newframe->Xflags = rg;\
-     newframe->Xrdepth = frame->Xrdepth + 1;\
+   newframe->Xrdepth = frame->Xrdepth + 1;\
-     newframe->Xprevframe = frame;\
+   newframe->Xprevframe = frame;\
-     frame = newframe;\
+   frame = newframe;\
-     DPRINTF(("restarting from line %d\n", __LINE__));\
+   DPRINTF(("restarting from line %d\n", __LINE__));\
-     goto HEAP_RECURSE;\
+   goto HEAP_RECURSE;\
-     }\
+   L_##rw:\
-   else\
+   DPRINTF(("jumped back to line %d\n", __LINE__));\
-     {\
-     DPRINTF(("longjumped back to line %d\n", __LINE__));\
-     frame = md->thisframe;\
-     rx = frame->Xresult;\
-     }\
    }
  #define RRETURN(ra)\
-Line 251 
 match(), which never changes. */
+Line 282 
 match(), which never changes. */
    (pcre_stack_free)(newframe);\
    if (frame != NULL)\
      {\
-     frame->Xresult = ra;\
+     rrc = ra;\
-     md->thisframe = frame;\
+     goto HEAP_RETURN;\
-     longjmp(frame->Xwhere, 1);\
      }\
    return ra;\
    }
-Line 268 
 typedef struct heapframe {
+Line 298 
 typedef struct heapframe {
    const uschar *Xeptr;
    const uschar *Xecode;
+   const uschar *Xmstart;
    int Xoffset_top;
    long int Xims;
    eptrblock *Xeptrb;
-Line 299 
 typedef struct heapframe {
+Line 330 
 typedef struct heapframe {
    int Xprop_category;
    int Xprop_chartype;
    int Xprop_script;
+   int Xoclength;
+   uschar Xocchars[8];
  #endif
    int Xctype;
-Line 316 
 typedef struct heapframe {
+Line 349 
 typedef struct heapframe {
    eptrblock Xnewptrb;
-   /* Place to pass back result, and where to jump back to */
+   /* Where to jump back to */
-   int  Xresult;
+   int Xwhere;
-   jmp_buf Xwhere;
  } heapframe;
-Line 347 
 made performance worse.
+Line 379 
 made performance worse.
  Arguments:
     eptr        pointer to current character in subject
     ecode       pointer to current position in compiled code
+    mstart      pointer to the current match start position (can be modified
+                  by encountering \K)
     offset_top  current top pointer
     md          pointer to "static" info for the match
     ims         current /i, /m, and /s options
-Line 356 
 Arguments:
+Line 390 
 Arguments:
                   match_condassert - this is an assertion condition
                   match_cbegroup - this is the start of an unlimited repeat
                     group that can match an empty string
-                  match_tail_recursed - this is a tail_recursed group
     rdepth      the recursion depth
  Returns:       MATCH_MATCH if matched            )  these values are >= 0
-Line 366 
 Returns:       MATCH_MATCH if matched
+Line 399 
 Returns:       MATCH_MATCH if matched
  */
  static int
- match(REGISTER USPTR eptr, REGISTER const uschar *ecode,
+ match(REGISTER USPTR eptr, REGISTER const uschar *ecode, const uschar *mstart,
    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
    int flags, unsigned int rdepth)
  {
-Line 394 
 frame->Xprevframe = NULL;            /*
+Line 427 
 frame->Xprevframe = NULL;            /*
  frame->Xeptr = eptr;
  frame->Xecode = ecode;
+ frame->Xmstart = mstart;
  frame->Xoffset_top = offset_top;
  frame->Xims = ims;
  frame->Xeptrb = eptrb;
-Line 408 
 HEAP_RECURSE:
+Line 442 
 HEAP_RECURSE:
  #define eptr               frame->Xeptr
  #define ecode              frame->Xecode
+ #define mstart             frame->Xmstart
  #define offset_top         frame->Xoffset_top
  #define ims                frame->Xims
  #define eptrb              frame->Xeptrb
-Line 441 
 HEAP_RECURSE:
+Line 476 
 HEAP_RECURSE:
  #define prop_category      frame->Xprop_category
  #define prop_chartype      frame->Xprop_chartype
  #define prop_script        frame->Xprop_script
+ #define oclength           frame->Xoclength
+ #define occhars            frame->Xocchars
  #endif
  #define ctype              frame->Xctype
-Line 494 
 int prop_fail_result;
+Line 531 
 int prop_fail_result;
  int prop_category;
  int prop_chartype;
  int prop_script;
+ int oclength;
+ uschar occhars[8];
  #endif
  int ctype;
-Line 534 
 defined). However, RMATCH isn't like a f
+Line 573 
 defined). However, RMATCH isn't like a f
  complicated macro. It has to be used in one particular way. This shouldn't,
  however, impact performance when true recursion is being used. */
+ #ifdef SUPPORT_UTF8
+ utf8 = md->utf8;       /* Local copy of the flag */
+ #else
+ utf8 = FALSE;
+ #endif
  /* First check that we haven't called match() too many times, or that we
  haven't exceeded the recursive call limit. */
-Line 542 
 if (rdepth >= md->match_limit_recursion)
+Line 587 
 if (rdepth >= md->match_limit_recursion)
  original_ims = ims;    /* Save for resetting on ')' */
- #ifdef SUPPORT_UTF8
- utf8 = md->utf8;       /* Local copy of the flag */
- #else
- utf8 = FALSE;
- #endif
  /* At the start of a group with an unlimited repeat that may match an empty
  string, the match_cbegroup flag is set. When this is the case, add the current
  subject pointer to the chain of such remembered pointers, to be checked when we
  hit the closing ket, in order to break infinite loops that match no characters.
- When match() is called in other circumstances, don't add to the chain. If this
+ When match() is called in other circumstances, don't add to the chain. The
- is a tail recursion, use a block from the workspace, as the one on the stack is
+ match_cbegroup flag must NOT be used with tail recursion, because the memory
- already used. */
+ block that is used is on the stack, so a new one may be required for each
+ match(). */
  if ((flags & match_cbegroup) != 0)
    {
-   eptrblock *p;
+   newptrb.epb_saved_eptr = eptr;
-   if ((flags & match_tail_recursed) != 0)
+   newptrb.epb_prev = eptrb;
-     {
+   eptrb = &newptrb;
-     if (md->eptrn >= EPTR_WORK_SIZE) RRETURN(PCRE_ERROR_NULLWSLIMIT);
-     p = md->eptrchain + md->eptrn++;
-     }
-   else p = &newptrb;
-   p->epb_saved_eptr = eptr;
-   p->epb_prev = eptrb;
-   eptrb = p;
    }
  /* Now start processing the opcodes. */
-Line 582 
 for (;;)
+Line 615 
 for (;;)
    if (md->partial &&
        eptr >= md->end_subject &&
-       eptr > md->start_match)
+       eptr > mstart)
      md->hitend = TRUE;
    switch(op)
      {
+     case OP_FAIL:
+     RRETURN(MATCH_NOMATCH);
+     case OP_PRUNE:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       ims, eptrb, flags, RM51);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     RRETURN(MATCH_PRUNE);
+     case OP_COMMIT:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       ims, eptrb, flags, RM52);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     RRETURN(MATCH_COMMIT);
+     case OP_SKIP:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       ims, eptrb, flags, RM53);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     md->start_match_ptr = eptr;   /* Pass back current position */
+     RRETURN(MATCH_SKIP);
+     case OP_THEN:
+     RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+       ims, eptrb, flags, RM54);
+     if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+     RRETURN(MATCH_THEN);
      /* Handle a capturing bracket. If there is space in the offset vector, save
      the current subject position in the working slot at the top of the vector.
      We mustn't change the current values of the data slot, because they may be
-Line 626 
 for (;;)
+Line 687 
 for (;;)
        flags = (op == OP_SCBRA)? match_cbegroup : 0;
        do
          {
-         RMATCH(rrc, eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
+         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
-           ims, eptrb, flags);
+           ims, eptrb, flags, RM1);
-         if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+         if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
          md->capture_last = save_capture_last;
          ecode += GET(ecode, 1);
          }
-Line 643 
 for (;;)
+Line 704 
 for (;;)
        RRETURN(MATCH_NOMATCH);
        }
-     /* Insufficient room for saving captured contents. Treat as a non-capturing
+     /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
-     bracket. */
+     as a non-capturing bracket. */
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
      DPRINTF(("insufficient capture room: treat as non-capturing\n"));
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+     /* VVVVVVVVVVVVVVVVVVVVVVVVV */
      /* Non-capturing bracket. Loop for all the alternatives. When we get to the
      final alternative within the brackets, we would return the result of a
      recursive call to match() whatever happened. We can reduce stack usage by
-     turning this into a tail recursion. */
+     turning this into a tail recursion, except in the case when match_cbegroup
+     is set.*/
      case OP_BRA:
      case OP_SBRA:
-Line 659 
 for (;;)
+Line 727 
 for (;;)
      flags = (op >= OP_SBRA)? match_cbegroup : 0;
      for (;;)
        {
-       if (ecode[GET(ecode, 1)] != OP_ALT)
+       if (ecode[GET(ecode, 1)] != OP_ALT)   /* Final alternative */
          {
-         ecode += _pcre_OP_lengths[*ecode];
+         if (flags == 0)    /* Not a possibly empty group */
-         flags |= match_tail_recursed;
+           {
-         DPRINTF(("bracket 0 tail recursion\n"));
+           ecode += _pcre_OP_lengths[*ecode];
-         goto TAIL_RECURSE;
+           DPRINTF(("bracket 0 tail recursion\n"));
+           goto TAIL_RECURSE;
+           }
+         /* Possibly empty group; can't use tail recursion. */
+         RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
+           eptrb, flags, RM48);
+         RRETURN(rrc);
          }
        /* For non-final alternatives, continue the loop for a NOMATCH result;
        otherwise return. */
-       RMATCH(rrc, eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
+       RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
-         eptrb, flags);
+         eptrb, flags, RM2);
-       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
      /* Control never reaches here. */
-Line 712 
 for (;;)
+Line 788 
 for (;;)
      else
        {
-       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
-           match_condassert);
+           match_condassert, RM3);
        if (rrc == MATCH_MATCH)
          {
          condition = TRUE;
          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
          }
-       else if (rrc != MATCH_NOMATCH)
+       else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
          {
          RRETURN(rrc);         /* Need braces because of following else */
          }
-Line 732 
 for (;;)
+Line 808 
 for (;;)
        }
      /* We are now at the branch that is to be obeyed. As there is only one,
-     we can use tail recursion to avoid using another stack frame. If the second
+     we can use tail recursion to avoid using another stack frame, except when
-     alternative doesn't exist, we can just plough on. */
+     match_cbegroup is required for an unlimited repeat of a possibly empty
+     group. If the second alternative doesn't exist, we can just plough on. */
      if (condition || *ecode == OP_ALT)
        {
        ecode += 1 + LINK_SIZE;
-       flags = match_tail_recursed | ((op == OP_SCOND)? match_cbegroup : 0);
+       if (op == OP_SCOND)        /* Possibly empty group */
-       goto TAIL_RECURSE;
+         {
+         RMATCH(eptr, ecode, offset_top, md, ims, eptrb, match_cbegroup, RM49);
+         RRETURN(rrc);
+         }
+       else                       /* Group must match something */
+         {
+         flags = 0;
+         goto TAIL_RECURSE;
+         }
        }
-     else
+     else                         /* Condition false & no 2nd alternative */
        {
        ecode += 1 + LINK_SIZE;
        }
      break;
-     /* End of the pattern. If we are in a top-level recursion, we should
+     /* End of the pattern, either real or forced. If we are in a top-level
-     restore the offsets appropriately and continue from after the call. */
+     recursion, we should restore the offsets appropriately and continue from
+     after the call. */
+     case OP_ACCEPT:
      case OP_END:
      if (md->recursive != NULL && md->recursive->group_num == 0)
        {
-Line 759 
 for (;;)
+Line 846 
 for (;;)
        md->recursive = rec->prevrec;
        memmove(md->offset_vector, rec->offset_save,
          rec->saved_max * sizeof(int));
-       md->start_match = rec->save_start;
+       mstart = rec->save_start;
        ims = original_ims;
        ecode = rec->after_call;
        break;
-Line 768 
 for (;;)
+Line 855 
 for (;;)
      /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
      string - backtracking will then try other alternatives, if any. */
-     if (md->notempty && eptr == md->start_match) RRETURN(MATCH_NOMATCH);
+     if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);
-     md->end_match_ptr = eptr;          /* Record where we ended */
+     md->end_match_ptr = eptr;           /* Record where we ended */
-     md->end_offset_top = offset_top;   /* and how many extracts were taken */
+     md->end_offset_top = offset_top;    /* and how many extracts were taken */
+     md->start_match_ptr = mstart;       /* and the start (\K can modify) */
      RRETURN(MATCH_MATCH);
      /* Change option settings */
-Line 791 
 for (;;)
+Line 879 
 for (;;)
      case OP_ASSERTBACK:
      do
        {
-       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
+         RM4);
        if (rrc == MATCH_MATCH) break;
-       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode, 1);
        }
      while (*ecode == OP_ALT);
-Line 817 
 for (;;)
+Line 906 
 for (;;)
      case OP_ASSERTBACK_NOT:
      do
        {
-       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
+         RM5);
        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
-       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode,1);
        }
      while (*ecode == OP_ALT);
-Line 843 
 for (;;)
+Line 933 
 for (;;)
          {
          eptr--;
          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
-         BACKCHAR(eptr)
+         BACKCHAR(eptr);
          }
        }
      else
-Line 874 
 for (;;)
+Line 964 
 for (;;)
        cb.offset_vector    = md->offset_vector;
        cb.subject          = (PCRE_SPTR)md->start_subject;
        cb.subject_length   = md->end_subject - md->start_subject;
-       cb.start_match      = md->start_match - md->start_subject;
+       cb.start_match      = mstart - md->start_subject;
        cb.current_position = eptr - md->start_subject;
        cb.pattern_position = GET(ecode, 2);
        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
-Line 936 
 for (;;)
+Line 1026 
 for (;;)
        memcpy(new_recursive.offset_save, md->offset_vector,
              new_recursive.saved_max * sizeof(int));
-       new_recursive.save_start = md->start_match;
+       new_recursive.save_start = mstart;
-       md->start_match = eptr;
+       mstart = eptr;
        /* OK, now we can do the recursion. For each top-level alternative we
        restore the offset and recursion data. */
-Line 946 
 for (;;)
+Line 1036 
 for (;;)
        flags = (*callpat >= OP_SBRA)? match_cbegroup : 0;
        do
          {
-         RMATCH(rrc, eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
+         RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
-           md, ims, eptrb, flags);
+           md, ims, eptrb, flags, RM6);
          if (rrc == MATCH_MATCH)
            {
            DPRINTF(("Recursion matched\n"));
-Line 956 
 for (;;)
+Line 1046 
 for (;;)
              (pcre_free)(new_recursive.offset_save);
            RRETURN(MATCH_MATCH);
            }
-         else if (rrc != MATCH_NOMATCH)
+         else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
            {
            DPRINTF(("Recursion gave error %d\n", rrc));
            RRETURN(rrc);
-Line 990 
 for (;;)
+Line 1080 
 for (;;)
      do
        {
-       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
-         eptrb, 0);
        if (rrc == MATCH_MATCH) break;
-       if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
        ecode += GET(ecode,1);
        }
      while (*ecode == OP_ALT);
-Line 1036 
 for (;;)
+Line 1125 
 for (;;)
      if (*ecode == OP_KETRMIN)
        {
-       RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM8);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode = prev;
-       flags = match_tail_recursed;
+       flags = 0;
        goto TAIL_RECURSE;
        }
      else  /* OP_KETRMAX */
        {
-       RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_cbegroup);
+       RMATCH(eptr, prev, offset_top, md, ims, eptrb, match_cbegroup, RM9);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += 1 + LINK_SIZE;
-       flags = match_tail_recursed;
+       flags = 0;
        goto TAIL_RECURSE;
        }
      /* Control never gets here */
-Line 1068 
 for (;;)
+Line 1157 
 for (;;)
      case OP_BRAZERO:
        {
        next = ecode+1;
-       RMATCH(rrc, eptr, next, offset_top, md, ims, eptrb, 0);
+       RMATCH(eptr, next, offset_top, md, ims, eptrb, 0, RM10);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        do next += GET(next,1); while (*next == OP_ALT);
        ecode = next + 1 + LINK_SIZE;
-Line 1079 
 for (;;)
+Line 1168 
 for (;;)
        {
        next = ecode+1;
        do next += GET(next, 1); while (*next == OP_ALT);
-       RMATCH(rrc, eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
+       RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0, RM11);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode++;
        }
-Line 1149 
 for (;;)
+Line 1238 
 for (;;)
          recursion_info *rec = md->recursive;
          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
          md->recursive = rec->prevrec;
-         md->start_match = rec->save_start;
+         mstart = rec->save_start;
          memcpy(md->offset_vector, rec->offset_save,
            rec->saved_max * sizeof(int));
          ecode = rec->after_call;
-Line 1178 
 for (;;)
+Line 1267 
 for (;;)
      /* The repeating kets try the rest of the pattern or restart from the
      preceding bracket, in the appropriate order. In the second case, we can use
-     tail recursion to avoid using another stack frame. */
+     tail recursion to avoid using another stack frame, unless we have an
+     unlimited repeat of a group that can match an empty string. */
      flags = (*prev >= OP_SBRA)? match_cbegroup : 0;
      if (*ecode == OP_KETRMIN)
        {
-       RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
+       RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM12);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+       if (flags != 0)    /* Could match an empty string */
+         {
+         RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM50);
+         RRETURN(rrc);
+         }
        ecode = prev;
-       flags |= match_tail_recursed;
        goto TAIL_RECURSE;
        }
      else  /* OP_KETRMAX */
        {
-       RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, flags);
+       RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM13);
        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
        ecode += 1 + LINK_SIZE;
-       flags = match_tail_recursed;
+       flags = 0;
        goto TAIL_RECURSE;
        }
      /* Control never gets here */
-Line 1228 
 for (;;)
+Line 1322 
 for (;;)
      ecode++;
      break;
+     /* Reset the start of match point */
+     case OP_SET_SOM:
+     mstart = eptr;
+     ecode++;
+     break;
      /* Assert before internal newline if multiline, or before a terminating
      newline unless endonly is set, else end of subject unless noteol is set. */
-Line 1425 
 for (;;)
+Line 1526 
 for (;;)
        case 0x000d:
        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
        break;
        case 0x000a:
+       break;
        case 0x000b:
        case 0x000c:
        case 0x0085:
        case 0x2028:
        case 0x2029:
+       if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+       break;
+       }
+     ecode++;
+     break;
+     case OP_NOT_HSPACE:
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     GETCHARINCTEST(c, eptr);
+     switch(c)
+       {
+       default: break;
+       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 */
+       RRETURN(MATCH_NOMATCH);
+       }
+     ecode++;
+     break;
+     case OP_HSPACE:
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     GETCHARINCTEST(c, eptr);
+     switch(c)
+       {
+       default: RRETURN(MATCH_NOMATCH);
+       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;
+       }
+     ecode++;
+     break;
+     case OP_NOT_VSPACE:
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     GETCHARINCTEST(c, eptr);
+     switch(c)
+       {
+       default: break;
+       case 0x0a:      /* LF */
+       case 0x0b:      /* VT */
+       case 0x0c:      /* FF */
+       case 0x0d:      /* CR */
+       case 0x85:      /* NEL */
+       case 0x2028:    /* LINE SEPARATOR */
+       case 0x2029:    /* PARAGRAPH SEPARATOR */
+       RRETURN(MATCH_NOMATCH);
+       }
+     ecode++;
+     break;
+     case OP_VSPACE:
+     if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+     GETCHARINCTEST(c, eptr);
+     switch(c)
+       {
+       default: RRETURN(MATCH_NOMATCH);
+       case 0x0a:      /* LF */
+       case 0x0b:      /* VT */
+       case 0x0c:      /* FF */
+       case 0x0d:      /* CR */
+       case 0x85:      /* NEL */
+       case 0x2028:    /* LINE SEPARATOR */
+       case 0x2029:    /* PARAGRAPH SEPARATOR */
        break;
        }
      ecode++;
-Line 1591 
 for (;;)
+Line 1792 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max || !match_ref(offset, eptr, length, md, ims))
              RRETURN(MATCH_NOMATCH);
-Line 1612 
 for (;;)
+Line 1813 
 for (;;)
            }
          while (eptr >= pp)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            eptr -= length;
            }
-Line 1717 
 for (;;)
+Line 1918 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              GETCHARINC(c, eptr);
-Line 1737 
 for (;;)
+Line 1938 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              c = *eptr++;
-Line 1774 
 for (;;)
+Line 1975 
 for (;;)
              }
            for (;;)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 1793 
 for (;;)
+Line 1994 
 for (;;)
              }
            while (eptr >= pp)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
-Line 1864 
 for (;;)
+Line 2065 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
            GETCHARINC(c, eptr);
-Line 1888 
 for (;;)
+Line 2089 
 for (;;)
            }
          for(;;)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
-           BACKCHAR(eptr)
+           if (utf8) BACKCHAR(eptr);
            }
          RRETURN(MATCH_NOMATCH);
          }
-Line 2045 
 for (;;)
+Line 2246 
 for (;;)
        if (length > 1)
          {
-         int oclength = 0;
-         uschar occhars[8];
  #ifdef SUPPORT_UCP
          unsigned int othercase;
          if ((ims & PCRE_CASELESS) != 0 &&
              (othercase = _pcre_ucp_othercase(fc)) != NOTACHAR)
            oclength = _pcre_ord2utf8(othercase, occhars);
+         else oclength = 0;
  #endif  /* SUPPORT_UCP */
          for (i = 1; i <= min; i++)
            {
            if (memcmp(eptr, charptr, length) == 0) eptr += length;
+ #ifdef SUPPORT_UCP
            /* Need braces because of following else */
            else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
            else
-Line 2065 
 for (;;)
+Line 2265 
 for (;;)
              if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
              eptr += oclength;
              }
+ #else   /* without SUPPORT_UCP */
+           else { RRETURN(MATCH_NOMATCH); }
+ #endif  /* SUPPORT_UCP */
            }
          if (min == max) continue;
-Line 2073 
 for (;;)
+Line 2276 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              if (memcmp(eptr, charptr, length) == 0) eptr += length;
+ #ifdef SUPPORT_UCP
              /* Need braces because of following else */
              else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
              else
-Line 2084 
 for (;;)
+Line 2288 
 for (;;)
                if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
                eptr += oclength;
                }
+ #else   /* without SUPPORT_UCP */
+             else { RRETURN (MATCH_NOMATCH); }
+ #endif  /* SUPPORT_UCP */
              }
            /* Control never gets here */
            }
-Line 2095 
 for (;;)
+Line 2302 
 for (;;)
              {
              if (eptr > md->end_subject - length) break;
              if (memcmp(eptr, charptr, length) == 0) eptr += length;
+ #ifdef SUPPORT_UCP
              else if (oclength == 0) break;
              else
                {
                if (memcmp(eptr, occhars, oclength) != 0) break;
                eptr += oclength;
                }
+ #else   /* without SUPPORT_UCP */
+             else break;
+ #endif  /* SUPPORT_UCP */
              }
            if (possessive) continue;
-           while (eptr >= pp)
+           for(;;)
             {
-            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
             if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (eptr == pp) RRETURN(MATCH_NOMATCH);
+ #ifdef SUPPORT_UCP
+            eptr--;
+            BACKCHAR(eptr);
+ #else   /* without SUPPORT_UCP */
             eptr -= length;
+ #endif  /* SUPPORT_UCP */
             }
-           RRETURN(MATCH_NOMATCH);
            }
          /* Control never gets here */
          }
-Line 2150 
 for (;;)
+Line 2366 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max || eptr >= md->end_subject ||
                fc != md->lcc[*eptr++])
-Line 2169 
 for (;;)
+Line 2385 
 for (;;)
          if (possessive) continue;
          while (eptr >= pp)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM25);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-Line 2188 
 for (;;)
+Line 2404 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max || eptr >= md->end_subject || fc != *eptr++)
              RRETURN(MATCH_NOMATCH);
-Line 2206 
 for (;;)
+Line 2422 
 for (;;)
          if (possessive) continue;
          while (eptr >= pp)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-Line 2351 
 for (;;)
+Line 2567 
 for (;;)
            register unsigned int d;
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              GETCHARINC(d, eptr);
              if (d < 256) d = md->lcc[d];
-Line 2365 
 for (;;)
+Line 2581 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])
                RRETURN(MATCH_NOMATCH);
-Line 2397 
 for (;;)
+Line 2613 
 for (;;)
          if (possessive) continue;
          for(;;)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM30);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 2415 
 for (;;)
+Line 2631 
 for (;;)
            if (possessive) continue;
            while (eptr >= pp)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM31);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
-Line 2460 
 for (;;)
+Line 2676 
 for (;;)
            register unsigned int d;
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              GETCHARINC(d, eptr);
              if (fi >= max || eptr >= md->end_subject || fc == d)
-Line 2473 
 for (;;)
+Line 2689 
 for (;;)
            {
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject || fc == *eptr++)
                RRETURN(MATCH_NOMATCH);
-Line 2504 
 for (;;)
+Line 2720 
 for (;;)
            if (possessive) continue;
            for(;;)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM34);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (eptr-- == pp) break;        /* Stop if tried at original pos */
              BACKCHAR(eptr);
-Line 2522 
 for (;;)
+Line 2738 
 for (;;)
            if (possessive) continue;
            while (eptr >= pp)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM35);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              eptr--;
              }
-Line 2629 
 for (;;)
+Line 2845 
 for (;;)
            for (i = 1; i <= min; i++)
              {
              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
-             GETCHARINC(c, eptr);
+             GETCHARINCTEST(c, eptr);
              }
            break;
-Line 2637 
 for (;;)
+Line 2853 
 for (;;)
            for (i = 1; i <= min; i++)
              {
              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
-             GETCHARINC(c, eptr);
+             GETCHARINCTEST(c, eptr);
              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
              if ((prop_chartype == ucp_Lu ||
                   prop_chartype == ucp_Ll ||
-Line 2650 
 for (;;)
+Line 2866 
 for (;;)
            for (i = 1; i <= min; i++)
              {
              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
-             GETCHARINC(c, eptr);
+             GETCHARINCTEST(c, eptr);
              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
              if ((prop_category == prop_value) == prop_fail_result)
                RRETURN(MATCH_NOMATCH);
-Line 2661 
 for (;;)
+Line 2877 
 for (;;)
            for (i = 1; i <= min; i++)
              {
              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
-             GETCHARINC(c, eptr);
+             GETCHARINCTEST(c, eptr);
              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
              if ((prop_chartype == prop_value) == prop_fail_result)
                RRETURN(MATCH_NOMATCH);
-Line 2672 
 for (;;)
+Line 2888 
 for (;;)
            for (i = 1; i <= min; i++)
              {
              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
-             GETCHARINC(c, eptr);
+             GETCHARINCTEST(c, eptr);
              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
              if ((prop_script == prop_value) == prop_fail_result)
                RRETURN(MATCH_NOMATCH);
-Line 2742 
 for (;;)
+Line 2958 
 for (;;)
              case 0x000d:
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
              break;
              case 0x000a:
+             break;
              case 0x000b:
              case 0x000c:
              case 0x0085:
              case 0x2028:
              case 0x2029:
+             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+             break;
+             }
+           }
+         break;
+         case OP_NOT_HSPACE:
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           GETCHARINC(c, eptr);
+           switch(c)
+             {
+             default: break;
+             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 */
+             RRETURN(MATCH_NOMATCH);
+             }
+           }
+         break;
+         case OP_HSPACE:
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           GETCHARINC(c, eptr);
+           switch(c)
+             {
+             default: RRETURN(MATCH_NOMATCH);
+             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;
+             }
+           }
+         break;
+         case OP_NOT_VSPACE:
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           GETCHARINC(c, eptr);
+           switch(c)
+             {
+             default: break;
+             case 0x0a:      /* LF */
+             case 0x0b:      /* VT */
+             case 0x0c:      /* FF */
+             case 0x0d:      /* CR */
+             case 0x85:      /* NEL */
+             case 0x2028:    /* LINE SEPARATOR */
+             case 0x2029:    /* PARAGRAPH SEPARATOR */
+             RRETURN(MATCH_NOMATCH);
+             }
+           }
+         break;
+         case OP_VSPACE:
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           GETCHARINC(c, eptr);
+           switch(c)
+             {
+             default: RRETURN(MATCH_NOMATCH);
+             case 0x0a:      /* LF */
+             case 0x0b:      /* VT */
+             case 0x0c:      /* FF */
+             case 0x0d:      /* CR */
+             case 0x85:      /* NEL */
+             case 0x2028:    /* LINE SEPARATOR */
+             case 0x2029:    /* PARAGRAPH SEPARATOR */
              break;
              }
            }
-Line 2777 
 for (;;)
+Line 3101 
 for (;;)
          for (i = 1; i <= min; i++)
            {
            if (eptr >= md->end_subject ||
-              (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))
+              (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
              RRETURN(MATCH_NOMATCH);
-           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+           while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
          break;
-Line 2797 
 for (;;)
+Line 3121 
 for (;;)
          for (i = 1; i <= min; i++)
            {
            if (eptr >= md->end_subject ||
-              (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))
+              (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))
              RRETURN(MATCH_NOMATCH);
-           while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+           while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
            }
          break;
-Line 2856 
 for (;;)
+Line 3180 
 for (;;)
              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
              break;
              case 0x000a:
+             break;
              case 0x000b:
              case 0x000c:
              case 0x0085:
+             if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+             break;
+             }
+           }
+         break;
+         case OP_NOT_HSPACE:
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           switch(*eptr++)
+             {
+             default: break;
+             case 0x09:      /* HT */
+             case 0x20:      /* SPACE */
+             case 0xa0:      /* NBSP */
+             RRETURN(MATCH_NOMATCH);
+             }
+           }
+         break;
+         case OP_HSPACE:
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           switch(*eptr++)
+             {
+             default: RRETURN(MATCH_NOMATCH);
+             case 0x09:      /* HT */
+             case 0x20:      /* SPACE */
+             case 0xa0:      /* NBSP */
+             break;
+             }
+           }
+         break;
+         case OP_NOT_VSPACE:
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           switch(*eptr++)
+             {
+             default: break;
+             case 0x0a:      /* LF */
+             case 0x0b:      /* VT */
+             case 0x0c:      /* FF */
+             case 0x0d:      /* CR */
+             case 0x85:      /* NEL */
+             RRETURN(MATCH_NOMATCH);
+             }
+           }
+         break;
+         case OP_VSPACE:
+         for (i = 1; i <= min; i++)
+           {
+           if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+           switch(*eptr++)
+             {
+             default: RRETURN(MATCH_NOMATCH);
+             case 0x0a:      /* LF */
+             case 0x0b:      /* VT */
+             case 0x0c:      /* FF */
+             case 0x0d:      /* CR */
+             case 0x85:      /* NEL */
              break;
              }
            }
-Line 2919 
 for (;;)
+Line 3310 
 for (;;)
            case PT_ANY:
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              GETCHARINC(c, eptr);
-Line 2930 
 for (;;)
+Line 3321 
 for (;;)
            case PT_LAMP:
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              GETCHARINC(c, eptr);
-Line 2945 
 for (;;)
+Line 3336 
 for (;;)
            case PT_GC:
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              GETCHARINC(c, eptr);
-Line 2958 
 for (;;)
+Line 3349 
 for (;;)
            case PT_PC:
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              GETCHARINC(c, eptr);
-Line 2971 
 for (;;)
+Line 3362 
 for (;;)
            case PT_SC:
            for (fi = min;; fi++)
              {
-             RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+             RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
              GETCHARINC(c, eptr);
-Line 2993 
 for (;;)
+Line 3384 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
            GETCHARINCTEST(c, eptr);
-Line 3022 
 for (;;)
+Line 3413 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max || eptr >= md->end_subject ||
                 (ctype == OP_ANY && (ims & PCRE_DOTALL) == 0 &&
-Line 3046 
 for (;;)
+Line 3437 
 for (;;)
                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
                break;
                case 0x000a:
+               break;
                case 0x000b:
                case 0x000c:
                case 0x0085:
                case 0x2028:
                case 0x2029:
+               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               break;
+               }
+             break;
+             case OP_NOT_HSPACE:
+             switch(c)
+               {
+               default: break;
+               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 */
+               RRETURN(MATCH_NOMATCH);
+               }
+             break;
+             case OP_HSPACE:
+             switch(c)
+               {
+               default: RRETURN(MATCH_NOMATCH);
+               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;
+               }
+             break;
+             case OP_NOT_VSPACE:
+             switch(c)
+               {
+               default: break;
+               case 0x0a:      /* LF */
+               case 0x0b:      /* VT */
+               case 0x0c:      /* FF */
+               case 0x0d:      /* CR */
+               case 0x85:      /* NEL */
+               case 0x2028:    /* LINE SEPARATOR */
+               case 0x2029:    /* PARAGRAPH SEPARATOR */
+               RRETURN(MATCH_NOMATCH);
+               }
+             break;
+             case OP_VSPACE:
+             switch(c)
+               {
+               default: RRETURN(MATCH_NOMATCH);
+               case 0x0a:      /* LF */
+               case 0x0b:      /* VT */
+               case 0x0c:      /* FF */
+               case 0x0d:      /* CR */
+               case 0x85:      /* NEL */
+               case 0x2028:    /* LINE SEPARATOR */
+               case 0x2029:    /* PARAGRAPH SEPARATOR */
                break;
                }
              break;
-Line 3096 
 for (;;)
+Line 3574 
 for (;;)
          {
          for (fi = min;; fi++)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (fi >= max || eptr >= md->end_subject ||
                 ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))
-Line 3118 
 for (;;)
+Line 3596 
 for (;;)
                case 0x000d:
                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
                break;
                case 0x000a:
+               break;
                case 0x000b:
                case 0x000c:
                case 0x0085:
+               if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+               break;
+               }
+             break;
+             case OP_NOT_HSPACE:
+             switch(c)
+               {
+               default: break;
+               case 0x09:      /* HT */
+               case 0x20:      /* SPACE */
+               case 0xa0:      /* NBSP */
+               RRETURN(MATCH_NOMATCH);
+               }
+             break;
+             case OP_HSPACE:
+             switch(c)
+               {
+               default: RRETURN(MATCH_NOMATCH);
+               case 0x09:      /* HT */
+               case 0x20:      /* SPACE */
+               case 0xa0:      /* NBSP */
+               break;
+               }
+             break;
+             case OP_NOT_VSPACE:
+             switch(c)
+               {
+               default: break;
+               case 0x0a:      /* LF */
+               case 0x0b:      /* VT */
+               case 0x0c:      /* FF */
+               case 0x0d:      /* CR */
+               case 0x85:      /* NEL */
+               RRETURN(MATCH_NOMATCH);
+               }
+             break;
+             case OP_VSPACE:
+             switch(c)
+               {
+               default: RRETURN(MATCH_NOMATCH);
+               case 0x0a:      /* LF */
+               case 0x0b:      /* VT */
+               case 0x0c:      /* FF */
+               case 0x0d:      /* CR */
+               case 0x85:      /* NEL */
                break;
                }
              break;
-Line 3242 
 for (;;)
+Line 3772 
 for (;;)
          if (possessive) continue;
          for(;;)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
-           BACKCHAR(eptr);
+           if (utf8) BACKCHAR(eptr);
            }
          }
-Line 3278 
 for (;;)
+Line 3808 
 for (;;)
          if (possessive) continue;
          for(;;)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            for (;;)                        /* Move back over one extended */
              {
              int len = 1;
-             BACKCHAR(eptr);
              if (!utf8) c = *eptr; else
                {
+               BACKCHAR(eptr);
                GETCHARLEN(c, eptr, len);
                }
              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);
-Line 3307 
 for (;;)
+Line 3837 
 for (;;)
          switch(ctype)
            {
            case OP_ANY:
-           /* Special code is required for UTF8, but when the maximum is
-           unlimited we don't need it, so we repeat the non-UTF8 code. This is
-           probably worth it, because .* is quite a common idiom. */
            if (max < INT_MAX)
              {
              if ((ims & PCRE_DOTALL) == 0)
-Line 3344 
 for (;;)
+Line 3869 
 for (;;)
                  {
                  if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
                  eptr++;
+                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                  }
-               break;
                }
              else
                {
-               c = max - min;
+               eptr = md->end_subject;
-               if (c > (unsigned int)(md->end_subject - eptr))
-                 c = md->end_subject - eptr;
-               eptr += c;
                }
              }
            break;
-Line 3379 
 for (;;)
+Line 3901 
 for (;;)
                }
              else
                {
-               if (c != 0x000a && c != 0x000b && c != 0x000c &&
+               if (c != 0x000a &&
-                   c != 0x0085 && c != 0x2028 && c != 0x2029)
+                   (md->bsr_anycrlf ||
+                    (c != 0x000b && c != 0x000c &&
+                     c != 0x0085 && c != 0x2028 && c != 0x2029)))
                  break;
                eptr += len;
                }
              }
            break;
+           case OP_NOT_HSPACE:
+           case OP_HSPACE:
+           for (i = min; i < max; i++)
+             {
+             BOOL gotspace;
+             int len = 1;
+             if (eptr >= md->end_subject) break;
+             GETCHARLEN(c, eptr, len);
+             switch(c)
+               {
+               default: gotspace = FALSE; break;
+               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 */
+               gotspace = TRUE;
+               break;
+               }
+             if (gotspace == (ctype == OP_NOT_HSPACE)) break;
+             eptr += len;
+             }
+           break;
+           case OP_NOT_VSPACE:
+           case OP_VSPACE:
+           for (i = min; i < max; i++)
+             {
+             BOOL gotspace;
+             int len = 1;
+             if (eptr >= md->end_subject) break;
+             GETCHARLEN(c, eptr, len);
+             switch(c)
+               {
+               default: gotspace = FALSE; break;
+               case 0x0a:      /* LF */
+               case 0x0b:      /* VT */
+               case 0x0c:      /* FF */
+               case 0x0d:      /* CR */
+               case 0x85:      /* NEL */
+               case 0x2028:    /* LINE SEPARATOR */
+               case 0x2029:    /* PARAGRAPH SEPARATOR */
+               gotspace = TRUE;
+               break;
+               }
+             if (gotspace == (ctype == OP_NOT_VSPACE)) break;
+             eptr += len;
+             }
+           break;
            case OP_NOT_DIGIT:
            for (i = min; i < max; i++)
              {
-Line 3462 
 for (;;)
+Line 4050 
 for (;;)
          if (possessive) continue;
          for(;;)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM46);
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            if (eptr-- == pp) break;        /* Stop if tried at original pos */
            BACKCHAR(eptr);
            }
          }
        else
- #endif
+ #endif  /* SUPPORT_UTF8 */
        /* Not UTF-8 mode */
          {
-Line 3506 
 for (;;)
+Line 4094 
 for (;;)
                }
              else
                {
-               if (c != 0x000a && c != 0x000b && c != 0x000c && c != 0x0085)
+               if (c != 0x000a &&
+                   (md->bsr_anycrlf ||
+                     (c != 0x000b && c != 0x000c && c != 0x0085)))
                  break;
                eptr++;
                }
              }
            break;
+           case OP_NOT_HSPACE:
+           for (i = min; i < max; i++)
+             {
+             if (eptr >= md->end_subject) break;
+             c = *eptr;
+             if (c == 0x09 || c == 0x20 || c == 0xa0) break;
+             eptr++;
+             }
+           break;
+           case OP_HSPACE:
+           for (i = min; i < max; i++)
+             {
+             if (eptr >= md->end_subject) break;
+             c = *eptr;
+             if (c != 0x09 && c != 0x20 && c != 0xa0) break;
+             eptr++;
+             }
+           break;
+           case OP_NOT_VSPACE:
+           for (i = min; i < max; i++)
+             {
+             if (eptr >= md->end_subject) break;
+             c = *eptr;
+             if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
+               break;
+             eptr++;
+             }
+           break;
+           case OP_VSPACE:
+           for (i = min; i < max; i++)
+             {
+             if (eptr >= md->end_subject) break;
+             c = *eptr;
+             if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
+               break;
+             eptr++;
+             }
+           break;
            case OP_NOT_DIGIT:
            for (i = min; i < max; i++)
              {
-Line 3576 
 for (;;)
+Line 4208 
 for (;;)
          if (possessive) continue;
          while (eptr >= pp)
            {
-           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM47);
            eptr--;
            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
            }
-Line 3602 
 for (;;)
+Line 4234 
 for (;;)
    }             /* End of main loop */
  /* Control never reaches here */
+ /* When compiling to use the heap rather than the stack for recursive calls to
+ match(), the RRETURN() macro jumps here. The number that is saved in
+ frame->Xwhere indicates which label we actually want to return to. */
+ #ifdef NO_RECURSE
+ #define LBL(val) case val: goto L_RM##val;
+ HEAP_RETURN:
+ switch (frame->Xwhere)
+   {
+   LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
+   LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
+   LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
+   LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
+   LBL(53) LBL(54)
+ #ifdef SUPPORT_UTF8
+   LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
+   LBL(32) LBL(34) LBL(42) LBL(46)
+ #ifdef SUPPORT_UCP
+   LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
+ #endif  /* SUPPORT_UCP */
+ #endif  /* SUPPORT_UTF8 */
+   default:
+   DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
+   return PCRE_ERROR_INTERNAL;
+   }
+ #undef LBL
+ #endif  /* NO_RECURSE */
  }
-Line 3614 
 Undefine all the macros that were define
+Line 4275 
 Undefine all the macros that were define
  #ifdef NO_RECURSE
  #undef eptr
  #undef ecode
+ #undef mstart
  #undef offset_top
  #undef ims
  #undef eptrb
-Line 3686 
 Returns:          > 0 => success; value
+Line 4348 
 Returns:          > 0 => success; value
                   < -1 => some kind of unexpected problem
  */
- PCRE_DATA_SCOPE int
+ PCRE_EXP_DEFN int
  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
    int offsetcount)
-Line 3711 
 const uschar *start_bits = NULL;
+Line 4373 
 const uschar *start_bits = NULL;
  USPTR start_match = (USPTR)subject + start_offset;
  USPTR end_subject;
  USPTR req_byte_ptr = start_match - 1;
- eptrblock eptrchain[EPTR_WORK_SIZE];
  pcre_study_data internal_study;
  const pcre_study_data *study;
-Line 3774 
 if (re->magic_number != MAGIC_NUMBER)
+Line 4435 
 if (re->magic_number != MAGIC_NUMBER)
  /* Set up other data */
  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
- startline = (re->options & PCRE_STARTLINE) != 0;
+ startline = (re->flags & PCRE_STARTLINE) != 0;
  firstline = (re->options & PCRE_FIRSTLINE) != 0;
  /* The code starts after the real_pcre block and the capture name table. */
-Line 3797 
 md->partial = (options & PCRE_PARTIAL) !
+Line 4458 
 md->partial = (options & PCRE_PARTIAL) !
  md->hitend = FALSE;
  md->recursive = NULL;                   /* No recursion at top level */
- md->eptrchain = eptrchain;              /* Make workspace generally available */
  md->lcc = tables + lcc_offset;
  md->ctypes = tables + ctypes_offset;
- /* Handle different types of newline. The two bits give four cases. If nothing
+ /* Handle different \R options. */
- is set at run time, whatever was used at compile time applies. */
- switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : options) &
+ switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
-        PCRE_NEWLINE_BITS)
+   {
+   case 0:
+   if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
+     md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
+   else
+ #ifdef BSR_ANYCRLF
+   md->bsr_anycrlf = TRUE;
+ #else
+   md->bsr_anycrlf = FALSE;
+ #endif
+   break;
+   case PCRE_BSR_ANYCRLF:
+   md->bsr_anycrlf = TRUE;
+   break;
+   case PCRE_BSR_UNICODE:
+   md->bsr_anycrlf = FALSE;
+   break;
+   default: return PCRE_ERROR_BADNEWLINE;
+   }
+ /* 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 :
+         (pcre_uint32)options) & PCRE_NEWLINE_BITS)
    {
    case 0: newline = NEWLINE; break;   /* Compile-time default */
    case PCRE_NEWLINE_CR: newline = '\r'; break;
-Line 3814 
 switch ((((options & PCRE_NEWLINE_BITS)
+Line 4500 
 switch ((((options & PCRE_NEWLINE_BITS)
    case PCRE_NEWLINE_CR+
         PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; 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 3840 
 else
+Line 4531 
 else
  /* Partial matching is supported only for a restricted set of regexes at the
  moment. */
- if (md->partial && (re->options & PCRE_NOPARTIAL) != 0)
+ if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
    return PCRE_ERROR_BADPARTIAL;
  /* Check a UTF-8 string if required. Unfortunately there's no way of passing
-Line 3917 
 studied, there may be a bitmap of possib
+Line 4608 
 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 3932 
 if (!anchored)
+Line 4623 
 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 3948 
 the loop runs just once. */
+Line 4639 
 the loop runs just once. */
  for(;;)
    {
    USPTR save_end_subject = end_subject;
+   USPTR new_start_match;
    /* Reset the maximum number of extractions we might see. */
-Line 3978 
 for(;;)
+Line 4670 
 for(;;)
      if (first_byte_caseless)
        while (start_match < end_subject &&
               md->lcc[*start_match] != first_byte)
-         start_match++;
+         { NEXTCHAR(start_match); }
      else
        while (start_match < end_subject && *start_match != first_byte)
-         start_match++;
+         { NEXTCHAR(start_match); }
      }
    /* Or to just after a linebreak for a multiline match if possible */
-Line 3991 
 for(;;)
+Line 4683 
 for(;;)
      if (start_match > md->start_subject + start_offset)
        {
        while (start_match <= end_subject && !WAS_NEWLINE(start_match))
+         { NEXTCHAR(start_match); }
+       /* 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 (start_match[-1] == '\r' &&
+            (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
+            start_match < end_subject &&
+            *start_match == '\n')
          start_match++;
        }
      }
-Line 4002 
 for(;;)
+Line 4704 
 for(;;)
      while (start_match < end_subject)
        {
        register unsigned int c = *start_match;
-       if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break;
+       if ((start_bits[c/8] & (1 << (c&7))) == 0)
+         { NEXTCHAR(start_match); }
+       else break;
        }
      }
-Line 4078 
 for(;;)
+Line 4782 
 for(;;)
    /* OK, we can now run the match. */
-   md->start_match = start_match;
+   md->start_match_ptr = start_match;
    md->match_call_count = 0;
-   md->eptrn = 0;                          /* Next free eptrchain slot */
+   rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);
-   rc = match(start_match, md->start_code, 2, md, ims, NULL, 0, 0);
+   switch(rc)
+     {
+     /* NOMATCH and PRUNE advance by one character. THEN at this level acts
+     exactly like PRUNE. */
-   /* Any return other than MATCH_NOMATCH breaks the loop. */
+     case MATCH_NOMATCH:
+     case MATCH_PRUNE:
+     case MATCH_THEN:
+     new_start_match = start_match + 1;
+ #ifdef SUPPORT_UTF8
+     if (utf8)
+       while(new_start_match < end_subject && (*new_start_match & 0xc0) == 0x80)
+         new_start_match++;
+ #endif
+     break;
+     /* SKIP passes back the next starting point explicitly. */
-   if (rc != MATCH_NOMATCH) break;
+     case MATCH_SKIP:
+     new_start_match = md->start_match_ptr;
+     break;
+     /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
+     case MATCH_COMMIT:
+     rc = MATCH_NOMATCH;
+     goto ENDLOOP;
+     /* Any other return is some kind of error. */
+     default:
+     goto ENDLOOP;
+     }
+   /* Control reaches here for the various types of "no match at this point"
+   result. Reset the code to MATCH_NOMATCH for subsequent checking. */
+   rc = MATCH_NOMATCH;
    /* If PCRE_FIRSTLINE is set, the match must happen before or at the first
    newline in the subject (though it may continue over the newline). Therefore,
-Line 4093 
 for(;;)
+Line 4831 
 for(;;)
    if (firstline && IS_NEWLINE(start_match)) break;
-   /* Advance the match position by one character. */
+   /* Advance to new matching position */
-   start_match++;
+   start_match = new_start_match;
- #ifdef SUPPORT_UTF8
-   if (utf8)
-     while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
-       start_match++;
- #endif
    /* Break the loop if the pattern is anchored or if we have passed the end of
    the subject. */
    if (anchored || start_match > 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 (start_match[-1] == '\r' &&
-        (md->nltype == NLTYPE_ANY || md->nllen == 2) &&
+       start_match < end_subject &&
-        start_match < end_subject &&
+       *start_match == '\n' &&
-        *start_match == '\n')
+       (re->flags & PCRE_HASCRORLF) == 0 &&
+         (md->nltype == NLTYPE_ANY ||
+          md->nltype == NLTYPE_ANYCRLF ||
+          md->nllen == 2))
      start_match++;
    }   /* End of for(;;) "bumpalong" loop */
-Line 4123 
 for(;;)
+Line 4860 
 for(;;)
  /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
  conditions is true:
- (1) The pattern is anchored;
+ (1) The pattern is anchored or the match was failed by (*COMMIT);
  (2) We are past the end of the subject;
-Line 4138 
 processing, copy those that we can. In t
+Line 4875 
 processing, copy those that we can. In t
  certain parts of the pattern were not used, even though there are more
  capturing parentheses than vector slots. */
+ ENDLOOP:
  if (rc == MATCH_MATCH)
    {
    if (using_temporary_offsets)
-Line 4158 
 if (rc == MATCH_MATCH)
+Line 4897 
 if (rc == MATCH_MATCH)
    rc = md->offset_overflow? 0 : md->end_offset_top/2;
-   /* If there is space, set up the whole thing as substring 0. */
+   /* If there is space, set up the whole thing as substring 0. The value of
+   md->start_match_ptr might be modified if \K was encountered on the success
+   matching path. */
    if (offsetcount < 2) rc = 0; else
      {
-     offsets[0] = start_match - md->start_subject;
+     offsets[0] = md->start_match_ptr - md->start_subject;
      offsets[1] = md->end_match_ptr - md->start_subject;
      }

 Legend:



Removed from v.96
 


changed lines


 
Added in v.298
 Legend:



Removed from v.96
 


changed lines


 
Added in v.298
-Removed from v.96
+Added in v.298

	ViewVC Help
Powered by ViewVC 1.1.5