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

Diff of /code/trunk/pcre_exec.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 443 by ph10, Sun Sep 13 16:00:08 2009 UTC revision 550 by ph10, Sun Oct 10 16:24:11 2010 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                         Written by Philip Hazel                         Written by Philip Hazel
9             Copyright (c) 1997-2009 University of Cambridge             Copyright (c) 1997-2010 University of Cambridge
10    
11  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
12  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 71  defined PCRE_ERROR_xxx codes, which are Line 71  defined PCRE_ERROR_xxx codes, which are
71  /* Special internal returns from the match() function. Make them sufficiently  /* Special internal returns from the match() function. Make them sufficiently
72  negative to avoid the external error codes. */  negative to avoid the external error codes. */
73    
74  #define MATCH_COMMIT       (-999)  #define MATCH_ACCEPT       (-999)
75  #define MATCH_PRUNE        (-998)  #define MATCH_COMMIT       (-998)
76  #define MATCH_SKIP         (-997)  #define MATCH_PRUNE        (-997)
77  #define MATCH_THEN         (-996)  #define MATCH_SKIP         (-996)
78    #define MATCH_SKIP_ARG     (-995)
79    #define MATCH_THEN         (-994)
80    
81    /* This is a convenience macro for code that occurs many times. */
82    
83    #define MRRETURN(ra) \
84      { \
85      md->mark = markptr; \
86      RRETURN(ra); \
87      }
88    
89  /* Maximum number of ints of offset to save on the stack for recursive calls.  /* Maximum number of ints of offset to save on the stack for recursive calls.
90  If the offset vector is bigger, malloc is used. This should be a multiple of 3,  If the offset vector is bigger, malloc is used. This should be a multiple of 3,
# Line 89  static const char rep_max[] = { 0, 0, 0, Line 99  static const char rep_max[] = { 0, 0, 0,
99    
100    
101    
102  #ifdef DEBUG  #ifdef PCRE_DEBUG
103  /*************************************************  /*************************************************
104  *        Debugging function to print chars       *  *        Debugging function to print chars       *
105  *************************************************/  *************************************************/
# Line 141  match_ref(int offset, register USPTR ept Line 151  match_ref(int offset, register USPTR ept
151  {  {
152  USPTR p = md->start_subject + md->offset_vector[offset];  USPTR p = md->start_subject + md->offset_vector[offset];
153    
154  #ifdef DEBUG  #ifdef PCRE_DEBUG
155  if (eptr >= md->end_subject)  if (eptr >= md->end_subject)
156    printf("matching subject <null>");    printf("matching subject <null>");
157  else  else
# Line 245  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM Line 255  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
255         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
256         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
257         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
258         RM51,  RM52, RM53, RM54 };         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
259           RM61,  RM62 };
260    
261  /* These versions of the macros use the stack, as normal. There are debugging  /* These versions of the macros use the stack, as normal. There are debugging
262  versions and production versions. Note that the "rw" argument of RMATCH isn't  versions and production versions. Note that the "rw" argument of RMATCH isn't
263  actuall used in this definition. */  actually used in this definition. */
264    
265  #ifndef NO_RECURSE  #ifndef NO_RECURSE
266  #define REGISTER register  #define REGISTER register
267    
268  #ifdef DEBUG  #ifdef PCRE_DEBUG
269  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
270    { \    { \
271    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
272    rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1); \    rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1); \
273    printf("to line %d\n", __LINE__); \    printf("to line %d\n", __LINE__); \
274    }    }
275  #define RRETURN(ra) \  #define RRETURN(ra) \
# Line 268  actuall used in this definition. */ Line 279  actuall used in this definition. */
279    }    }
280  #else  #else
281  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
282    rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1)    rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1)
283  #define RRETURN(ra) return ra  #define RRETURN(ra) return ra
284  #endif  #endif
285    
# Line 284  argument of match(), which never changes Line 295  argument of match(), which never changes
295  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw)\
296    {\    {\
297    heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\    heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
298      if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
299    frame->Xwhere = rw; \    frame->Xwhere = rw; \
300    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
301    newframe->Xecode = rb;\    newframe->Xecode = rb;\
302    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
303      newframe->Xmarkptr = markptr;\
304    newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
305    newframe->Xims = re;\    newframe->Xims = re;\
306    newframe->Xeptrb = rf;\    newframe->Xeptrb = rf;\
# Line 303  argument of match(), which never changes Line 316  argument of match(), which never changes
316    
317  #define RRETURN(ra)\  #define RRETURN(ra)\
318    {\    {\
319    heapframe *newframe = frame;\    heapframe *oldframe = frame;\
320    frame = newframe->Xprevframe;\    frame = oldframe->Xprevframe;\
321    (pcre_stack_free)(newframe);\    (pcre_stack_free)(oldframe);\
322    if (frame != NULL)\    if (frame != NULL)\
323      {\      {\
324      rrc = ra;\      rrc = ra;\
# Line 325  typedef struct heapframe { Line 338  typedef struct heapframe {
338    USPTR Xeptr;    USPTR Xeptr;
339    const uschar *Xecode;    const uschar *Xecode;
340    USPTR Xmstart;    USPTR Xmstart;
341      USPTR Xmarkptr;
342    int Xoffset_top;    int Xoffset_top;
343    long int Xims;    long int Xims;
344    eptrblock *Xeptrb;    eptrblock *Xeptrb;
# Line 411  the subject. */ Line 425  the subject. */
425    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
426      {\      {\
427      md->hitend = TRUE;\      md->hitend = TRUE;\
428      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
429      }      }
430    
431  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
432    if (md->partial && eptr > mstart)\    if (md->partial != 0 && eptr > mstart)\
433      {\      {\
434      md->hitend = TRUE;\      md->hitend = TRUE;\
435      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
436      }      }
437    
438    
# Line 432  Arguments: Line 446  Arguments:
446     ecode       pointer to current position in compiled code     ecode       pointer to current position in compiled code
447     mstart      pointer to the current match start position (can be modified     mstart      pointer to the current match start position (can be modified
448                   by encountering \K)                   by encountering \K)
449       markptr     pointer to the most recent MARK name, or NULL
450     offset_top  current top pointer     offset_top  current top pointer
451     md          pointer to "static" info for the match     md          pointer to "static" info for the match
452     ims         current /i, /m, and /s options     ims         current /i, /m, and /s options
# Line 445  Arguments: Line 460  Arguments:
460    
461  Returns:       MATCH_MATCH if matched            )  these values are >= 0  Returns:       MATCH_MATCH if matched            )  these values are >= 0
462                 MATCH_NOMATCH if failed to match  )                 MATCH_NOMATCH if failed to match  )
463                   a negative MATCH_xxx value for PRUNE, SKIP, etc
464                 a negative PCRE_ERROR_xxx value if aborted by an error condition                 a negative PCRE_ERROR_xxx value if aborted by an error condition
465                   (e.g. stopped by repeated call or recursion limit)                   (e.g. stopped by repeated call or recursion limit)
466  */  */
467    
468  static int  static int
469  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
470    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,    const uschar *markptr, int offset_top, match_data *md, unsigned long int ims,
471    int flags, unsigned int rdepth)    eptrblock *eptrb, int flags, unsigned int rdepth)
472  {  {
473  /* These variables do not need to be preserved over recursion in this function,  /* These variables do not need to be preserved over recursion in this function,
474  so they can be ordinary variables in all cases. Mark some of them with  so they can be ordinary variables in all cases. Mark some of them with
# Line 473  heap whenever RMATCH() does a "recursion Line 489  heap whenever RMATCH() does a "recursion
489    
490  #ifdef NO_RECURSE  #ifdef NO_RECURSE
491  heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));  heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));
492    if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
493  frame->Xprevframe = NULL;            /* Marks the top level */  frame->Xprevframe = NULL;            /* Marks the top level */
494    
495  /* Copy in the original argument variables */  /* Copy in the original argument variables */
# Line 480  frame->Xprevframe = NULL;            /* Line 497  frame->Xprevframe = NULL;            /*
497  frame->Xeptr = eptr;  frame->Xeptr = eptr;
498  frame->Xecode = ecode;  frame->Xecode = ecode;
499  frame->Xmstart = mstart;  frame->Xmstart = mstart;
500    frame->Xmarkptr = markptr;
501  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
502  frame->Xims = ims;  frame->Xims = ims;
503  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
# Line 495  HEAP_RECURSE: Line 513  HEAP_RECURSE:
513  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
514  #define ecode              frame->Xecode  #define ecode              frame->Xecode
515  #define mstart             frame->Xmstart  #define mstart             frame->Xmstart
516    #define markptr            frame->Xmarkptr
517  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
518  #define ims                frame->Xims  #define ims                frame->Xims
519  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
# Line 622  TAIL_RECURSE: Line 641  TAIL_RECURSE:
641  /* OK, now we can get on with the real code of the function. Recursive calls  /* OK, now we can get on with the real code of the function. Recursive calls
642  are specified by the macro RMATCH and RRETURN is used to return. When  are specified by the macro RMATCH and RRETURN is used to return. When
643  NO_RECURSE is *not* defined, these just turn into a recursive call to match()  NO_RECURSE is *not* defined, these just turn into a recursive call to match()
644  and a "return", respectively (possibly with some debugging if DEBUG is  and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
645  defined). However, RMATCH isn't like a function call because it's quite a  defined). However, RMATCH isn't like a function call because it's quite a
646  complicated macro. It has to be used in one particular way. This shouldn't,  complicated macro. It has to be used in one particular way. This shouldn't,
647  however, impact performance when true recursion is being used. */  however, impact performance when true recursion is being used. */
# Line 666  for (;;) Line 685  for (;;)
685    
686    switch(op)    switch(op)
687      {      {
688        case OP_MARK:
689        markptr = ecode + 2;
690        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
691          ims, eptrb, flags, RM55);
692    
693        /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
694        argument, and we must check whether that argument matches this MARK's
695        argument. It is passed back in md->start_match_ptr (an overloading of that
696        variable). If it does match, we reset that variable to the current subject
697        position and return MATCH_SKIP. Otherwise, pass back the return code
698        unaltered. */
699    
700        if (rrc == MATCH_SKIP_ARG &&
701            strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
702          {
703          md->start_match_ptr = eptr;
704          RRETURN(MATCH_SKIP);
705          }
706    
707        if (md->mark == NULL) md->mark = markptr;
708        RRETURN(rrc);
709    
710      case OP_FAIL:      case OP_FAIL:
711      RRETURN(MATCH_NOMATCH);      MRRETURN(MATCH_NOMATCH);
712    
713        case OP_COMMIT:
714        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
715          ims, eptrb, flags, RM52);
716        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
717        MRRETURN(MATCH_COMMIT);
718    
719      case OP_PRUNE:      case OP_PRUNE:
720      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
721        ims, eptrb, flags, RM51);        ims, eptrb, flags, RM51);
722      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
723      RRETURN(MATCH_PRUNE);      MRRETURN(MATCH_PRUNE);
724    
725      case OP_COMMIT:      case OP_PRUNE_ARG:
726      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
727        ims, eptrb, flags, RM52);        ims, eptrb, flags, RM56);
728      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
729      RRETURN(MATCH_COMMIT);      md->mark = ecode + 2;
730        RRETURN(MATCH_PRUNE);
731    
732      case OP_SKIP:      case OP_SKIP:
733      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
734        ims, eptrb, flags, RM53);        ims, eptrb, flags, RM53);
735      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
736      md->start_match_ptr = eptr;   /* Pass back current position */      md->start_match_ptr = eptr;   /* Pass back current position */
737      RRETURN(MATCH_SKIP);      MRRETURN(MATCH_SKIP);
738    
739        case OP_SKIP_ARG:
740        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
741          ims, eptrb, flags, RM57);
742        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
743    
744        /* Pass back the current skip name by overloading md->start_match_ptr and
745        returning the special MATCH_SKIP_ARG return code. This will either be
746        caught by a matching MARK, or get to the top, where it is treated the same
747        as PRUNE. */
748    
749        md->start_match_ptr = ecode + 2;
750        RRETURN(MATCH_SKIP_ARG);
751    
752        /* For THEN (and THEN_ARG) we pass back the address of the bracket or
753        the alt that is at the start of the current branch. This makes it possible
754        to skip back past alternatives that precede the THEN within the current
755        branch. */
756    
757      case OP_THEN:      case OP_THEN:
758      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
759        ims, eptrb, flags, RM54);        ims, eptrb, flags, RM54);
760      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
761        md->start_match_ptr = ecode - GET(ecode, 1);
762        MRRETURN(MATCH_THEN);
763    
764        case OP_THEN_ARG:
765        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1+LINK_SIZE],
766          offset_top, md, ims, eptrb, flags, RM58);
767        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
768        md->start_match_ptr = ecode - GET(ecode, 1);
769        md->mark = ecode + LINK_SIZE + 2;
770      RRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
771    
772      /* Handle a capturing bracket. If there is space in the offset vector, save      /* Handle a capturing bracket. If there is space in the offset vector, save
# Line 713  for (;;) Line 788  for (;;)
788      number = GET2(ecode, 1+LINK_SIZE);      number = GET2(ecode, 1+LINK_SIZE);
789      offset = number << 1;      offset = number << 1;
790    
791  #ifdef DEBUG  #ifdef PCRE_DEBUG
792      printf("start bracket %d\n", number);      printf("start bracket %d\n", number);
793      printf("subject=");      printf("subject=");
794      pchars(eptr, 16, TRUE, md);      pchars(eptr, 16, TRUE, md);
# Line 728  for (;;) Line 803  for (;;)
803        save_capture_last = md->capture_last;        save_capture_last = md->capture_last;
804    
805        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
806        md->offset_vector[md->offset_end - number] = eptr - md->start_subject;        md->offset_vector[md->offset_end - number] =
807            (int)(eptr - md->start_subject);
808    
809        flags = (op == OP_SCBRA)? match_cbegroup : 0;        flags = (op == OP_SCBRA)? match_cbegroup : 0;
810        do        do
811          {          {
812          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
813            ims, eptrb, flags, RM1);            ims, eptrb, flags, RM1);
814          if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);          if (rrc != MATCH_NOMATCH &&
815                (rrc != MATCH_THEN || md->start_match_ptr != ecode))
816              RRETURN(rrc);
817          md->capture_last = save_capture_last;          md->capture_last = save_capture_last;
818          ecode += GET(ecode, 1);          ecode += GET(ecode, 1);
819          }          }
# Line 747  for (;;) Line 825  for (;;)
825        md->offset_vector[offset+1] = save_offset2;        md->offset_vector[offset+1] = save_offset2;
826        md->offset_vector[md->offset_end - number] = save_offset3;        md->offset_vector[md->offset_end - number] = save_offset3;
827    
828          if (rrc != MATCH_THEN) md->mark = markptr;
829        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
830        }        }
831    
# Line 786  for (;;) Line 865  for (;;)
865    
866          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
867            eptrb, flags, RM48);            eptrb, flags, RM48);
868            if (rrc == MATCH_NOMATCH) md->mark = markptr;
869          RRETURN(rrc);          RRETURN(rrc);
870          }          }
871    
# Line 794  for (;;) Line 874  for (;;)
874    
875        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
876          eptrb, flags, RM2);          eptrb, flags, RM2);
877        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH &&
878              (rrc != MATCH_THEN || md->start_match_ptr != ecode))
879            RRETURN(rrc);
880        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
881        }        }
882      /* Control never reaches here. */      /* Control never reaches here. */
# Line 821  for (;;) Line 903  for (;;)
903          cb.callout_number   = ecode[LINK_SIZE+2];          cb.callout_number   = ecode[LINK_SIZE+2];
904          cb.offset_vector    = md->offset_vector;          cb.offset_vector    = md->offset_vector;
905          cb.subject          = (PCRE_SPTR)md->start_subject;          cb.subject          = (PCRE_SPTR)md->start_subject;
906          cb.subject_length   = md->end_subject - md->start_subject;          cb.subject_length   = (int)(md->end_subject - md->start_subject);
907          cb.start_match      = mstart - md->start_subject;          cb.start_match      = (int)(mstart - md->start_subject);
908          cb.current_position = eptr - md->start_subject;          cb.current_position = (int)(eptr - md->start_subject);
909          cb.pattern_position = GET(ecode, LINK_SIZE + 3);          cb.pattern_position = GET(ecode, LINK_SIZE + 3);
910          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
911          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
912          cb.capture_last     = md->capture_last;          cb.capture_last     = md->capture_last;
913          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
914          if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);          if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
915          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
916          }          }
917        ecode += _pcre_OP_lengths[OP_CALLOUT];        ecode += _pcre_OP_lengths[OP_CALLOUT];
# Line 839  for (;;) Line 921  for (;;)
921    
922      /* Now see what the actual condition is */      /* Now see what the actual condition is */
923    
924      if (condcode == OP_RREF)         /* Recursion test */      if (condcode == OP_RREF || condcode == OP_NRREF)    /* Recursion test */
925        {        {
926        offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/        if (md->recursive == NULL)                /* Not recursing => FALSE */
927        condition = md->recursive != NULL &&          {
928          (offset == RREF_ANY || offset == md->recursive->group_num);          condition = FALSE;
929        ecode += condition? 3 : GET(ecode, 1);          ecode += GET(ecode, 1);
930            }
931          else
932            {
933            int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
934            condition =  (recno == RREF_ANY || recno == md->recursive->group_num);
935    
936            /* If the test is for recursion into a specific subpattern, and it is
937            false, but the test was set up by name, scan the table to see if the
938            name refers to any other numbers, and test them. The condition is true
939            if any one is set. */
940    
941            if (!condition && condcode == OP_NRREF && recno != RREF_ANY)
942              {
943              uschar *slotA = md->name_table;
944              for (i = 0; i < md->name_count; i++)
945                {
946                if (GET2(slotA, 0) == recno) break;
947                slotA += md->name_entry_size;
948                }
949    
950              /* Found a name for the number - there can be only one; duplicate
951              names for different numbers are allowed, but not vice versa. First
952              scan down for duplicates. */
953    
954              if (i < md->name_count)
955                {
956                uschar *slotB = slotA;
957                while (slotB > md->name_table)
958                  {
959                  slotB -= md->name_entry_size;
960                  if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
961                    {
962                    condition = GET2(slotB, 0) == md->recursive->group_num;
963                    if (condition) break;
964                    }
965                  else break;
966                  }
967    
968                /* Scan up for duplicates */
969    
970                if (!condition)
971                  {
972                  slotB = slotA;
973                  for (i++; i < md->name_count; i++)
974                    {
975                    slotB += md->name_entry_size;
976                    if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
977                      {
978                      condition = GET2(slotB, 0) == md->recursive->group_num;
979                      if (condition) break;
980                      }
981                    else break;
982                    }
983                  }
984                }
985              }
986    
987            /* Chose branch according to the condition */
988    
989            ecode += condition? 3 : GET(ecode, 1);
990            }
991        }        }
992    
993      else if (condcode == OP_CREF)    /* Group used test */      else if (condcode == OP_CREF || condcode == OP_NCREF)  /* Group used test */
994        {        {
995        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
996        condition = offset < offset_top && md->offset_vector[offset] >= 0;        condition = offset < offset_top && md->offset_vector[offset] >= 0;
997    
998          /* If the numbered capture is unset, but the reference was by name,
999          scan the table to see if the name refers to any other numbers, and test
1000          them. The condition is true if any one is set. This is tediously similar
1001          to the code above, but not close enough to try to amalgamate. */
1002    
1003          if (!condition && condcode == OP_NCREF)
1004            {
1005            int refno = offset >> 1;
1006            uschar *slotA = md->name_table;
1007    
1008            for (i = 0; i < md->name_count; i++)
1009              {
1010              if (GET2(slotA, 0) == refno) break;
1011              slotA += md->name_entry_size;
1012              }
1013    
1014            /* Found a name for the number - there can be only one; duplicate names
1015            for different numbers are allowed, but not vice versa. First scan down
1016            for duplicates. */
1017    
1018            if (i < md->name_count)
1019              {
1020              uschar *slotB = slotA;
1021              while (slotB > md->name_table)
1022                {
1023                slotB -= md->name_entry_size;
1024                if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1025                  {
1026                  offset = GET2(slotB, 0) << 1;
1027                  condition = offset < offset_top &&
1028                    md->offset_vector[offset] >= 0;
1029                  if (condition) break;
1030                  }
1031                else break;
1032                }
1033    
1034              /* Scan up for duplicates */
1035    
1036              if (!condition)
1037                {
1038                slotB = slotA;
1039                for (i++; i < md->name_count; i++)
1040                  {
1041                  slotB += md->name_entry_size;
1042                  if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1043                    {
1044                    offset = GET2(slotB, 0) << 1;
1045                    condition = offset < offset_top &&
1046                      md->offset_vector[offset] >= 0;
1047                    if (condition) break;
1048                    }
1049                  else break;
1050                  }
1051                }
1052              }
1053            }
1054    
1055          /* Chose branch according to the condition */
1056    
1057        ecode += condition? 3 : GET(ecode, 1);        ecode += condition? 3 : GET(ecode, 1);
1058        }        }
1059    
# Line 874  for (;;) Line 1077  for (;;)
1077          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
1078          while (*ecode == OP_ALT) ecode += GET(ecode, 1);          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
1079          }          }
1080        else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)        else if (rrc != MATCH_NOMATCH &&
1081                  (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1082          {          {
1083          RRETURN(rrc);         /* Need braces because of following else */          RRETURN(rrc);         /* Need braces because of following else */
1084          }          }
# Line 911  for (;;) Line 1115  for (;;)
1115      break;      break;
1116    
1117    
1118        /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
1119        to close any currently open capturing brackets. */
1120    
1121        case OP_CLOSE:
1122        number = GET2(ecode, 1);
1123        offset = number << 1;
1124    
1125    #ifdef PCRE_DEBUG
1126          printf("end bracket %d at *ACCEPT", number);
1127          printf("\n");
1128    #endif
1129    
1130        md->capture_last = number;
1131        if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1132          {
1133          md->offset_vector[offset] =
1134            md->offset_vector[md->offset_end - number];
1135          md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1136          if (offset_top <= offset) offset_top = offset + 2;
1137          }
1138        ecode += 3;
1139        break;
1140    
1141    
1142      /* End of the pattern, either real or forced. If we are in a top-level      /* End of the pattern, either real or forced. If we are in a top-level
1143      recursion, we should restore the offsets appropriately and continue from      recursion, we should restore the offsets appropriately and continue from
1144      after the call. */      after the call. */
# Line 924  for (;;) Line 1152  for (;;)
1152        md->recursive = rec->prevrec;        md->recursive = rec->prevrec;
1153        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
1154          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
1155        mstart = rec->save_start;        offset_top = rec->save_offset_top;
1156        ims = original_ims;        ims = original_ims;
1157        ecode = rec->after_call;        ecode = rec->after_call;
1158        break;        break;
# Line 939  for (;;) Line 1167  for (;;)
1167          (md->notempty ||          (md->notempty ||
1168            (md->notempty_atstart &&            (md->notempty_atstart &&
1169              mstart == md->start_subject + md->start_offset)))              mstart == md->start_subject + md->start_offset)))
1170        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1171    
1172      /* Otherwise, we have a match. */      /* Otherwise, we have a match. */
1173    
1174      md->end_match_ptr = eptr;           /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
1175      md->end_offset_top = offset_top;    /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
1176      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
1177      RRETURN(MATCH_MATCH);  
1178        /* For some reason, the macros don't work properly if an expression is
1179        given as the argument to MRRETURN when the heap is in use. */
1180    
1181        rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1182        MRRETURN(rrc);
1183    
1184      /* Change option settings */      /* Change option settings */
1185    
# Line 968  for (;;) Line 1201  for (;;)
1201        {        {
1202        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1203          RM4);          RM4);
1204        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1205        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);          {
1206            mstart = md->start_match_ptr;   /* In case \K reset it */
1207            break;
1208            }
1209          if (rrc != MATCH_NOMATCH &&
1210              (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1211            RRETURN(rrc);
1212        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1213        }        }
1214      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1215      if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);      if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
1216    
1217      /* If checking an assertion for a condition, return MATCH_MATCH. */      /* If checking an assertion for a condition, return MATCH_MATCH. */
1218    
# Line 987  for (;;) Line 1226  for (;;)
1226      offset_top = md->end_offset_top;      offset_top = md->end_offset_top;
1227      continue;      continue;
1228    
1229      /* Negative assertion: all branches must fail to match */      /* Negative assertion: all branches must fail to match. Encountering SKIP,
1230        PRUNE, or COMMIT means we must assume failure without checking subsequent
1231        branches. */
1232    
1233      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1234      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
# Line 995  for (;;) Line 1236  for (;;)
1236        {        {
1237        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1238          RM5);          RM5);
1239        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
1240        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1241            {
1242            do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1243            break;
1244            }
1245          if (rrc != MATCH_NOMATCH &&
1246              (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1247            RRETURN(rrc);
1248        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1249        }        }
1250      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 1019  for (;;) Line 1267  for (;;)
1267        while (i-- > 0)        while (i-- > 0)
1268          {          {
1269          eptr--;          eptr--;
1270          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1271          BACKCHAR(eptr);          BACKCHAR(eptr);
1272          }          }
1273        }        }
# Line 1030  for (;;) Line 1278  for (;;)
1278    
1279        {        {
1280        eptr -= GET(ecode, 1);        eptr -= GET(ecode, 1);
1281        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1282        }        }
1283    
1284      /* Save the earliest consulted character, then skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
# Line 1051  for (;;) Line 1299  for (;;)
1299        cb.callout_number   = ecode[1];        cb.callout_number   = ecode[1];
1300        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
1301        cb.subject          = (PCRE_SPTR)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
1302        cb.subject_length   = md->end_subject - md->start_subject;        cb.subject_length   = (int)(md->end_subject - md->start_subject);
1303        cb.start_match      = mstart - md->start_subject;        cb.start_match      = (int)(mstart - md->start_subject);
1304        cb.current_position = eptr - md->start_subject;        cb.current_position = (int)(eptr - md->start_subject);
1305        cb.pattern_position = GET(ecode, 2);        cb.pattern_position = GET(ecode, 2);
1306        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1307        cb.capture_top      = offset_top/2;        cb.capture_top      = offset_top/2;
1308        cb.capture_last     = md->capture_last;        cb.capture_last     = md->capture_last;
1309        cb.callout_data     = md->callout_data;        cb.callout_data     = md->callout_data;
1310        if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);        if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1311        if (rrc < 0) RRETURN(rrc);        if (rrc < 0) RRETURN(rrc);
1312        }        }
1313      ecode += 2 + 2*LINK_SIZE;      ecode += 2 + 2*LINK_SIZE;
# Line 1114  for (;;) Line 1362  for (;;)
1362    
1363        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1364              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
1365        new_recursive.save_start = mstart;        new_recursive.save_offset_top = offset_top;
       mstart = eptr;  
1366    
1367        /* OK, now we can do the recursion. For each top-level alternative we        /* OK, now we can do the recursion. For each top-level alternative we
1368        restore the offset and recursion data. */        restore the offset and recursion data. */
# Line 1126  for (;;) Line 1373  for (;;)
1373          {          {
1374          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1375            md, ims, eptrb, flags, RM6);            md, ims, eptrb, flags, RM6);
1376          if (rrc == MATCH_MATCH)          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1377            {            {
1378            DPRINTF(("Recursion matched\n"));            DPRINTF(("Recursion matched\n"));
1379            md->recursive = new_recursive.prevrec;            md->recursive = new_recursive.prevrec;
1380            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1381              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1382            RRETURN(MATCH_MATCH);            MRRETURN(MATCH_MATCH);
1383            }            }
1384          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH &&
1385                    (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1386            {            {
1387            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1388            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
# Line 1153  for (;;) Line 1401  for (;;)
1401        md->recursive = new_recursive.prevrec;        md->recursive = new_recursive.prevrec;
1402        if (new_recursive.offset_save != stacksave)        if (new_recursive.offset_save != stacksave)
1403          (pcre_free)(new_recursive.offset_save);          (pcre_free)(new_recursive.offset_save);
1404        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1405        }        }
1406      /* Control never reaches here */      /* Control never reaches here */
1407    
# Line 1162  for (;;) Line 1410  for (;;)
1410      a move back into the brackets. Friedl calls these "atomic" subpatterns.      a move back into the brackets. Friedl calls these "atomic" subpatterns.
1411      Check the alternative branches in turn - the matching won't pass the KET      Check the alternative branches in turn - the matching won't pass the KET
1412      for this kind of subpattern. If any one branch matches, we carry on as at      for this kind of subpattern. If any one branch matches, we carry on as at
1413      the end of a normal bracket, leaving the subject pointer. */      the end of a normal bracket, leaving the subject pointer, but resetting
1414        the start-of-match value in case it was changed by \K. */
1415    
1416      case OP_ONCE:      case OP_ONCE:
1417      prev = ecode;      prev = ecode;
# Line 1171  for (;;) Line 1420  for (;;)
1420      do      do
1421        {        {
1422        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
1423        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
1424        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);          {
1425            mstart = md->start_match_ptr;
1426            break;
1427            }
1428          if (rrc != MATCH_NOMATCH &&
1429              (rrc != MATCH_THEN || md->start_match_ptr != ecode))
1430            RRETURN(rrc);
1431        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1432        }        }
1433      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 1290  for (;;) Line 1545  for (;;)
1545        }        }
1546      else saved_eptr = NULL;      else saved_eptr = NULL;
1547    
1548      /* If we are at the end of an assertion group, stop matching and return      /* If we are at the end of an assertion group or an atomic group, stop
1549      MATCH_MATCH, but record the current high water mark for use by positive      matching and return MATCH_MATCH, but record the current high water mark for
1550      assertions. Do this also for the "once" (atomic) groups. */      use by positive assertions. We also need to record the match start in case
1551        it was changed by \K. */
1552    
1553      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1554          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
# Line 1300  for (;;) Line 1556  for (;;)
1556        {        {
1557        md->end_match_ptr = eptr;      /* For ONCE */        md->end_match_ptr = eptr;      /* For ONCE */
1558        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
1559        RRETURN(MATCH_MATCH);        md->start_match_ptr = mstart;
1560          MRRETURN(MATCH_MATCH);
1561        }        }
1562    
1563      /* For capturing groups we have to check the group number back at the start      /* For capturing groups we have to check the group number back at the start
# Line 1314  for (;;) Line 1571  for (;;)
1571        number = GET2(prev, 1+LINK_SIZE);        number = GET2(prev, 1+LINK_SIZE);
1572        offset = number << 1;        offset = number << 1;
1573    
1574  #ifdef DEBUG  #ifdef PCRE_DEBUG
1575        printf("end bracket %d", number);        printf("end bracket %d", number);
1576        printf("\n");        printf("\n");
1577  #endif  #endif
# Line 1324  for (;;) Line 1581  for (;;)
1581          {          {
1582          md->offset_vector[offset] =          md->offset_vector[offset] =
1583            md->offset_vector[md->offset_end - number];            md->offset_vector[md->offset_end - number];
1584          md->offset_vector[offset+1] = eptr - md->start_subject;          md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1585          if (offset_top <= offset) offset_top = offset + 2;          if (offset_top <= offset) offset_top = offset + 2;
1586          }          }
1587    
# Line 1336  for (;;) Line 1593  for (;;)
1593          recursion_info *rec = md->recursive;          recursion_info *rec = md->recursive;
1594          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1595          md->recursive = rec->prevrec;          md->recursive = rec->prevrec;
         mstart = rec->save_start;  
1596          memcpy(md->offset_vector, rec->offset_save,          memcpy(md->offset_vector, rec->offset_save,
1597            rec->saved_max * sizeof(int));            rec->saved_max * sizeof(int));
1598            offset_top = rec->save_offset_top;
1599          ecode = rec->after_call;          ecode = rec->after_call;
1600          ims = original_ims;          ims = original_ims;
1601          break;          break;
# Line 1395  for (;;) Line 1652  for (;;)
1652      /* Start of subject unless notbol, or after internal newline if multiline */      /* Start of subject unless notbol, or after internal newline if multiline */
1653    
1654      case OP_CIRC:      case OP_CIRC:
1655      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1656      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1657        {        {
1658        if (eptr != md->start_subject &&        if (eptr != md->start_subject &&
1659            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1660          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1661        ecode++;        ecode++;
1662        break;        break;
1663        }        }
# Line 1409  for (;;) Line 1666  for (;;)
1666      /* Start of subject assertion */      /* Start of subject assertion */
1667    
1668      case OP_SOD:      case OP_SOD:
1669      if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
1670      ecode++;      ecode++;
1671      break;      break;
1672    
1673      /* Start of match assertion */      /* Start of match assertion */
1674    
1675      case OP_SOM:      case OP_SOM:
1676      if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
1677      ecode++;      ecode++;
1678      break;      break;
1679    
# Line 1434  for (;;) Line 1691  for (;;)
1691      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1692        {        {
1693        if (eptr < md->end_subject)        if (eptr < md->end_subject)
1694          { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }          { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
1695        else        else
1696          { if (md->noteol) RRETURN(MATCH_NOMATCH); }          { if (md->noteol) MRRETURN(MATCH_NOMATCH); }
1697        ecode++;        ecode++;
1698        break;        break;
1699        }        }
1700      else      else
1701        {        {
1702        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) MRRETURN(MATCH_NOMATCH);
1703        if (!md->endonly)        if (!md->endonly)
1704          {          {
1705          if (eptr != md->end_subject &&          if (eptr != md->end_subject &&
1706              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1707            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
1708          ecode++;          ecode++;
1709          break;          break;
1710          }          }
# Line 1457  for (;;) Line 1714  for (;;)
1714      /* End of subject assertion (\z) */      /* End of subject assertion (\z) */
1715    
1716      case OP_EOD:      case OP_EOD:
1717      if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
1718      ecode++;      ecode++;
1719      break;      break;
1720    
# Line 1466  for (;;) Line 1723  for (;;)
1723      case OP_EODN:      case OP_EODN:
1724      if (eptr != md->end_subject &&      if (eptr != md->end_subject &&
1725          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1726        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1727      ecode++;      ecode++;
1728      break;      break;
1729    
# Line 1484  for (;;) Line 1741  for (;;)
1741  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
1742        if (utf8)        if (utf8)
1743          {          {
1744            /* Get status of previous character */
1745    
1746          if (eptr == md->start_subject) prev_is_word = FALSE; else          if (eptr == md->start_subject) prev_is_word = FALSE; else
1747            {            {
1748            USPTR lastptr = eptr - 1;            USPTR lastptr = eptr - 1;
1749            while((*lastptr & 0xc0) == 0x80) lastptr--;            while((*lastptr & 0xc0) == 0x80) lastptr--;
1750            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
1751            GETCHAR(c, lastptr);            GETCHAR(c, lastptr);
1752    #ifdef SUPPORT_UCP
1753              if (md->use_ucp)
1754                {
1755                if (c == '_') prev_is_word = TRUE; else
1756                  {
1757                  int cat = UCD_CATEGORY(c);
1758                  prev_is_word = (cat == ucp_L || cat == ucp_N);
1759                  }
1760                }
1761              else
1762    #endif
1763            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1764            }            }
1765    
1766            /* Get status of next character */
1767    
1768          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
1769            {            {
1770            SCHECK_PARTIAL();            SCHECK_PARTIAL();
# Line 1500  for (;;) Line 1773  for (;;)
1773          else          else
1774            {            {
1775            GETCHAR(c, eptr);            GETCHAR(c, eptr);
1776    #ifdef SUPPORT_UCP
1777              if (md->use_ucp)
1778                {
1779                if (c == '_') cur_is_word = TRUE; else
1780                  {
1781                  int cat = UCD_CATEGORY(c);
1782                  cur_is_word = (cat == ucp_L || cat == ucp_N);
1783                  }
1784                }
1785              else
1786    #endif
1787            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1788            }            }
1789          }          }
1790        else        else
1791  #endif  #endif
1792    
1793        /* Not in UTF-8 mode */        /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
1794          consistency with the behaviour of \w we do use it in this case. */
1795    
1796          {          {
1797            /* Get status of previous character */
1798    
1799          if (eptr == md->start_subject) prev_is_word = FALSE; else          if (eptr == md->start_subject) prev_is_word = FALSE; else
1800            {            {
1801            if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;            if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
1802    #ifdef SUPPORT_UCP
1803              if (md->use_ucp)
1804                {
1805                c = eptr[-1];
1806                if (c == '_') prev_is_word = TRUE; else
1807                  {
1808                  int cat = UCD_CATEGORY(c);
1809                  prev_is_word = (cat == ucp_L || cat == ucp_N);
1810                  }
1811                }
1812              else
1813    #endif
1814            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
1815            }            }
1816    
1817            /* Get status of next character */
1818    
1819          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
1820            {            {
1821            SCHECK_PARTIAL();            SCHECK_PARTIAL();
1822            cur_is_word = FALSE;            cur_is_word = FALSE;
1823            }            }
1824          else cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);          else
1825    #ifdef SUPPORT_UCP
1826            if (md->use_ucp)
1827              {
1828              c = *eptr;
1829              if (c == '_') cur_is_word = TRUE; else
1830                {
1831                int cat = UCD_CATEGORY(c);
1832                cur_is_word = (cat == ucp_L || cat == ucp_N);
1833                }
1834              }
1835            else
1836    #endif
1837            cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
1838          }          }
1839    
1840        /* Now see if the situation is what we want */        /* Now see if the situation is what we want */
1841    
1842        if ((*ecode++ == OP_WORD_BOUNDARY)?        if ((*ecode++ == OP_WORD_BOUNDARY)?
1843             cur_is_word == prev_is_word : cur_is_word != prev_is_word)             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
1844          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1845        }        }
1846      break;      break;
1847    
1848      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1849    
1850      case OP_ANY:      case OP_ANY:
1851      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
1852      /* Fall through */      /* Fall through */
1853    
1854      case OP_ALLANY:      case OP_ALLANY:
1855      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1856        {        {
1857        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1858        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1859        }        }
1860      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1861      ecode++;      ecode++;
# Line 1553  for (;;) Line 1868  for (;;)
1868      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1869        {        {
1870        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1871        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1872        }        }
1873      ecode++;      ecode++;
1874      break;      break;
# Line 1562  for (;;) Line 1877  for (;;)
1877      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1878        {        {
1879        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1880        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1881        }        }
1882      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1883      if (      if (
# Line 1571  for (;;) Line 1886  for (;;)
1886  #endif  #endif
1887         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
1888         )         )
1889        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1890      ecode++;      ecode++;
1891      break;      break;
1892    
# Line 1579  for (;;) Line 1894  for (;;)
1894      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1895        {        {
1896        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1897        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1898        }        }
1899      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1900      if (      if (
# Line 1588  for (;;) Line 1903  for (;;)
1903  #endif  #endif
1904         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
1905         )         )
1906        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1907      ecode++;      ecode++;
1908      break;      break;
1909    
# Line 1596  for (;;) Line 1911  for (;;)
1911      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1912        {        {
1913        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1914        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1915        }        }
1916      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1917      if (      if (
# Line 1605  for (;;) Line 1920  for (;;)
1920  #endif  #endif
1921         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
1922         )         )
1923        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1924      ecode++;      ecode++;
1925      break;      break;
1926    
# Line 1613  for (;;) Line 1928  for (;;)
1928      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1929        {        {
1930        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1931        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1932        }        }
1933      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1934      if (      if (
# Line 1622  for (;;) Line 1937  for (;;)
1937  #endif  #endif
1938         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
1939         )         )
1940        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1941      ecode++;      ecode++;
1942      break;      break;
1943    
# Line 1630  for (;;) Line 1945  for (;;)
1945      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1946        {        {
1947        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1948        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1949        }        }
1950      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1951      if (      if (
# Line 1639  for (;;) Line 1954  for (;;)
1954  #endif  #endif
1955         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
1956         )         )
1957        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1958      ecode++;      ecode++;
1959      break;      break;
1960    
# Line 1647  for (;;) Line 1962  for (;;)
1962      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1963        {        {
1964        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1965        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1966        }        }
1967      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1968      if (      if (
# Line 1656  for (;;) Line 1971  for (;;)
1971  #endif  #endif
1972         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
1973         )         )
1974        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1975      ecode++;      ecode++;
1976      break;      break;
1977    
# Line 1664  for (;;) Line 1979  for (;;)
1979      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1980        {        {
1981        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1982        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1983        }        }
1984      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1985      switch(c)      switch(c)
1986        {        {
1987        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
1988        case 0x000d:        case 0x000d:
1989        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1990        break;        break;
# Line 1682  for (;;) Line 1997  for (;;)
1997        case 0x0085:        case 0x0085:
1998        case 0x2028:        case 0x2028:
1999        case 0x2029:        case 0x2029:
2000        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
2001        break;        break;
2002        }        }
2003      ecode++;      ecode++;
# Line 1692  for (;;) Line 2007  for (;;)
2007      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2008        {        {
2009        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2010        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2011        }        }
2012      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2013      switch(c)      switch(c)
# Line 1717  for (;;) Line 2032  for (;;)
2032        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2033        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2034        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2035        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2036        }        }
2037      ecode++;      ecode++;
2038      break;      break;
# Line 1726  for (;;) Line 2041  for (;;)
2041      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2042        {        {
2043        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2044        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2045        }        }
2046      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2047      switch(c)      switch(c)
2048        {        {
2049        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2050        case 0x09:      /* HT */        case 0x09:      /* HT */
2051        case 0x20:      /* SPACE */        case 0x20:      /* SPACE */
2052        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
# Line 1760  for (;;) Line 2075  for (;;)
2075      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2076        {        {
2077        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2078        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2079        }        }
2080      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2081      switch(c)      switch(c)
# Line 1773  for (;;) Line 2088  for (;;)
2088        case 0x85:      /* NEL */        case 0x85:      /* NEL */
2089        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2090        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2091        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2092        }        }
2093      ecode++;      ecode++;
2094      break;      break;
# Line 1782  for (;;) Line 2097  for (;;)
2097      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2098        {        {
2099        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2100        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2101        }        }
2102      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2103      switch(c)      switch(c)
2104        {        {
2105        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2106        case 0x0a:      /* LF */        case 0x0a:      /* LF */
2107        case 0x0b:      /* VT */        case 0x0b:      /* VT */
2108        case 0x0c:      /* FF */        case 0x0c:      /* FF */
# Line 1809  for (;;) Line 2124  for (;;)
2124      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2125        {        {
2126        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2127        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2128        }        }
2129      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2130        {        {
# Line 1818  for (;;) Line 2133  for (;;)
2133        switch(ecode[1])        switch(ecode[1])
2134          {          {
2135          case PT_ANY:          case PT_ANY:
2136          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);          if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2137          break;          break;
2138    
2139          case PT_LAMP:          case PT_LAMP:
2140          if ((prop->chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
2141               prop->chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
2142               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2143            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2144           break;          break;
2145    
2146          case PT_GC:          case PT_GC:
2147          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2148            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2149          break;          break;
2150    
2151          case PT_PC:          case PT_PC:
2152          if ((ecode[2] != prop->chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2153            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2154          break;          break;
2155    
2156          case PT_SC:          case PT_SC:
2157          if ((ecode[2] != prop->script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
2158            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2159            break;
2160    
2161            /* These are specials */
2162    
2163            case PT_ALNUM:
2164            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2165                 _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2166              MRRETURN(MATCH_NOMATCH);
2167            break;
2168    
2169            case PT_SPACE:    /* Perl space */
2170            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2171                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2172                   == (op == OP_NOTPROP))
2173              MRRETURN(MATCH_NOMATCH);
2174            break;
2175    
2176            case PT_PXSPACE:  /* POSIX space */
2177            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2178                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2179                 c == CHAR_FF || c == CHAR_CR)
2180                   == (op == OP_NOTPROP))
2181              MRRETURN(MATCH_NOMATCH);
2182            break;
2183    
2184            case PT_WORD:
2185            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2186                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2187                 c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2188              MRRETURN(MATCH_NOMATCH);
2189          break;          break;
2190    
2191            /* This should never occur */
2192    
2193          default:          default:
2194          RRETURN(PCRE_ERROR_INTERNAL);          RRETURN(PCRE_ERROR_INTERNAL);
2195          }          }
# Line 1858  for (;;) Line 2205  for (;;)
2205      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2206        {        {
2207        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2208        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2209        }        }
2210      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2211        {        {
2212        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
2213        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
2214        while (eptr < md->end_subject)        while (eptr < md->end_subject)
2215          {          {
2216          int len = 1;          int len = 1;
# Line 1908  for (;;) Line 2255  for (;;)
2255        referenced subpattern. */        referenced subpattern. */
2256    
2257        if (offset >= offset_top || md->offset_vector[offset] < 0)        if (offset >= offset_top || md->offset_vector[offset] < 0)
2258          length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1;          length = (md->jscript_compat)? 0 : (int)(md->end_subject - eptr + 1);
2259        else        else
2260          length = md->offset_vector[offset+1] - md->offset_vector[offset];          length = md->offset_vector[offset+1] - md->offset_vector[offset];
2261    
# Line 1942  for (;;) Line 2289  for (;;)
2289          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2290            {            {
2291            CHECK_PARTIAL();            CHECK_PARTIAL();
2292            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2293            }            }
2294          eptr += length;          eptr += length;
2295          continue;              /* With the main loop */          continue;              /* With the main loop */
# Line 1962  for (;;) Line 2309  for (;;)
2309          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2310            {            {
2311            CHECK_PARTIAL();            CHECK_PARTIAL();
2312            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2313            }            }
2314          eptr += length;          eptr += length;
2315          }          }
# Line 1980  for (;;) Line 2327  for (;;)
2327            {            {
2328            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2329            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2330            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2331            if (!match_ref(offset, eptr, length, md, ims))            if (!match_ref(offset, eptr, length, md, ims))
2332              {              {
2333              CHECK_PARTIAL();              CHECK_PARTIAL();
2334              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2335              }              }
2336            eptr += length;            eptr += length;
2337            }            }
# Line 1998  for (;;) Line 2345  for (;;)
2345          pp = eptr;          pp = eptr;
2346          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2347            {            {
2348            if (!match_ref(offset, eptr, length, md, ims)) break;            if (!match_ref(offset, eptr, length, md, ims))
2349                {
2350                CHECK_PARTIAL();
2351                break;
2352                }
2353            eptr += length;            eptr += length;
2354            }            }
2355          while (eptr >= pp)          while (eptr >= pp)
# Line 2007  for (;;) Line 2358  for (;;)
2358            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2359            eptr -= length;            eptr -= length;
2360            }            }
2361          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2362          }          }
2363        }        }
2364      /* Control never gets here */      /* Control never gets here */
# Line 2069  for (;;) Line 2420  for (;;)
2420            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2421              {              {
2422              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2423              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2424              }              }
2425            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2426            if (c > 255)            if (c > 255)
2427              {              {
2428              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2429              }              }
2430            else            else
2431              {              {
2432              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2433              }              }
2434            }            }
2435          }          }
# Line 2091  for (;;) Line 2442  for (;;)
2442            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2443              {              {
2444              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2445              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2446              }              }
2447            c = *eptr++;            c = *eptr++;
2448            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2449            }            }
2450          }          }
2451    
# Line 2116  for (;;) Line 2467  for (;;)
2467              {              {
2468              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2469              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2470              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2471              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2472                {                {
2473                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2474                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2475                }                }
2476              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2477              if (c > 255)              if (c > 255)
2478                {                {
2479                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2480                }                }
2481              else              else
2482                {                {
2483                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2484                }                }
2485              }              }
2486            }            }
# Line 2141  for (;;) Line 2492  for (;;)
2492              {              {
2493              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2494              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2495              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2496              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2497                {                {
2498                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2499                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2500                }                }
2501              c = *eptr++;              c = *eptr++;
2502              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2503              }              }
2504            }            }
2505          /* Control never gets here */          /* Control never gets here */
# Line 2167  for (;;) Line 2518  for (;;)
2518            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2519              {              {
2520              int len = 1;              int len = 1;
2521              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
2522                  {
2523                  SCHECK_PARTIAL();
2524                  break;
2525                  }
2526              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
2527              if (c > 255)              if (c > 255)
2528                {                {
# Line 2193  for (;;) Line 2548  for (;;)
2548            {            {
2549            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2550              {              {
2551              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
2552                  {
2553                  SCHECK_PARTIAL();
2554                  break;
2555                  }
2556              c = *eptr;              c = *eptr;
2557              if ((data[c/8] & (1 << (c&7))) == 0) break;              if ((data[c/8] & (1 << (c&7))) == 0) break;
2558              eptr++;              eptr++;
# Line 2206  for (;;) Line 2565  for (;;)
2565              }              }
2566            }            }
2567    
2568          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2569          }          }
2570        }        }
2571      /* Control never gets here */      /* Control never gets here */
# Line 2258  for (;;) Line 2617  for (;;)
2617          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2618            {            {
2619            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2620            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2621            }            }
2622          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2623          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2624          }          }
2625    
2626        /* If max == min we can continue with the main loop without the        /* If max == min we can continue with the main loop without the
# Line 2278  for (;;) Line 2637  for (;;)
2637            {            {
2638            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2639            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2640            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2641            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2642              {              {
2643              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2644              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2645              }              }
2646            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2647            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2648            }            }
2649          /* Control never gets here */          /* Control never gets here */
2650          }          }
# Line 2298  for (;;) Line 2657  for (;;)
2657          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2658            {            {
2659            int len = 1;            int len = 1;
2660            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject)
2661                {
2662                SCHECK_PARTIAL();
2663                break;
2664                }
2665            GETCHARLENTEST(c, eptr, len);            GETCHARLENTEST(c, eptr, len);
2666            if (!_pcre_xclass(c, data)) break;            if (!_pcre_xclass(c, data)) break;
2667            eptr += len;            eptr += len;
# Line 2310  for (;;) Line 2673  for (;;)
2673            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2674            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2675            }            }
2676          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2677          }          }
2678    
2679        /* Control never gets here */        /* Control never gets here */
# Line 2329  for (;;) Line 2692  for (;;)
2692        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2693          {          {
2694          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2695          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2696          }          }
2697        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2698        }        }
2699      else      else
2700  #endif  #endif
# Line 2341  for (;;) Line 2704  for (;;)
2704        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2705          {          {
2706          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2707          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2708          }          }
2709        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2710        ecode += 2;        ecode += 2;
2711        }        }
2712      break;      break;
# Line 2361  for (;;) Line 2724  for (;;)
2724        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2725          {          {
2726          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2727          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2728          }          }
2729    
2730        /* If the pattern character's value is < 128, we have only one byte, and        /* If the pattern character's value is < 128, we have only one byte, and
# Line 2369  for (;;) Line 2732  for (;;)
2732    
2733        if (fc < 128)        if (fc < 128)
2734          {          {
2735          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2736          }          }
2737    
2738        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 2388  for (;;) Line 2751  for (;;)
2751  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2752            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
2753  #endif  #endif
2754              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2755            }            }
2756          }          }
2757        }        }
# Line 2400  for (;;) Line 2763  for (;;)
2763        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2764          {          {
2765          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2766          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2767          }          }
2768        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2769        ecode += 2;        ecode += 2;
2770        }        }
2771      break;      break;
# Line 2496  for (;;) Line 2859  for (;;)
2859            else            else
2860              {              {
2861              CHECK_PARTIAL();              CHECK_PARTIAL();
2862              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2863              }              }
2864            }            }
2865    
# Line 2508  for (;;) Line 2871  for (;;)
2871              {              {
2872              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2873              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2874              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2875              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2876                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2877  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2519  for (;;) Line 2882  for (;;)
2882              else              else
2883                {                {
2884                CHECK_PARTIAL();                CHECK_PARTIAL();
2885                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2886                }                }
2887              }              }
2888            /* Control never gets here */            /* Control never gets here */
# Line 2537  for (;;) Line 2900  for (;;)
2900                       eptr <= md->end_subject - oclength &&                       eptr <= md->end_subject - oclength &&
2901                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
2902  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2903              else break;              else
2904                  {
2905                  CHECK_PARTIAL();
2906                  break;
2907                  }
2908              }              }
2909    
2910            if (possessive) continue;            if (possessive) continue;
# Line 2546  for (;;) Line 2913  for (;;)
2913              {              {
2914              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2915              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2916              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
2917  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2918              eptr--;              eptr--;
2919              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2589  for (;;) Line 2956  for (;;)
2956          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2957            {            {
2958            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2959            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2960            }            }
2961          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2962          }          }
2963        if (min == max) continue;        if (min == max) continue;
2964        if (minimize)        if (minimize)
# Line 2600  for (;;) Line 2967  for (;;)
2967            {            {
2968            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2969            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2970            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2971            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2972              {              {
2973              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2974              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2975              }              }
2976            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2977            }            }
2978          /* Control never gets here */          /* Control never gets here */
2979          }          }
# Line 2615  for (;;) Line 2982  for (;;)
2982          pp = eptr;          pp = eptr;
2983          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2984            {            {
2985            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;            if (eptr >= md->end_subject)
2986                {
2987                SCHECK_PARTIAL();
2988                break;
2989                }
2990              if (fc != md->lcc[*eptr]) break;
2991            eptr++;            eptr++;
2992            }            }
2993    
# Line 2627  for (;;) Line 2999  for (;;)
2999            eptr--;            eptr--;
3000            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3001            }            }
3002          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3003          }          }
3004        /* Control never gets here */        /* Control never gets here */
3005        }        }
# Line 2641  for (;;) Line 3013  for (;;)
3013          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
3014            {            {
3015            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3016            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3017            }            }
3018          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3019          }          }
3020    
3021        if (min == max) continue;        if (min == max) continue;
# Line 2654  for (;;) Line 3026  for (;;)
3026            {            {
3027            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
3028            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3029            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
3030            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3031              {              {
3032              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3033              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3034              }              }
3035            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3036            }            }
3037          /* Control never gets here */          /* Control never gets here */
3038          }          }
# Line 2669  for (;;) Line 3041  for (;;)
3041          pp = eptr;          pp = eptr;
3042          for (i = min; i < max; i++)          for (i = min; i < max; i++)
3043            {            {
3044            if (eptr >= md->end_subject || fc != *eptr) break;            if (eptr >= md->end_subject)
3045                {
3046                SCHECK_PARTIAL();
3047                break;
3048                }
3049              if (fc != *eptr) break;
3050            eptr++;            eptr++;
3051            }            }
3052          if (possessive) continue;          if (possessive) continue;
# Line 2680  for (;;) Line 3057  for (;;)
3057            eptr--;            eptr--;
3058            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3059            }            }
3060          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3061          }          }
3062        }        }
3063      /* Control never gets here */      /* Control never gets here */
# Line 2692  for (;;) Line 3069  for (;;)
3069      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
3070        {        {
3071        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3072        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
3073        }        }
3074      ecode++;      ecode++;
3075      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
# Line 2702  for (;;) Line 3079  for (;;)
3079        if (c < 256)        if (c < 256)
3080  #endif  #endif
3081        c = md->lcc[c];        c = md->lcc[c];
3082        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
3083        }        }
3084      else      else
3085        {        {
3086        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
3087        }        }
3088      break;      break;
3089    
# Line 2800  for (;;) Line 3177  for (;;)
3177            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3178              {              {
3179              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3180              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3181              }              }
3182            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3183            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3184            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3185            }            }
3186          }          }
3187        else        else
# Line 2817  for (;;) Line 3194  for (;;)
3194            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3195              {              {
3196              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3197              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3198              }              }
3199            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3200            }            }
3201          }          }
3202    
# Line 2836  for (;;) Line 3213  for (;;)
3213              {              {
3214              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3215              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3216              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3217              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3218                {                {
3219                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3220                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3221                }                }
3222              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3223              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3224              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3225              }              }
3226            }            }
3227          else          else
# Line 2855  for (;;) Line 3232  for (;;)
3232              {              {
3233              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3234              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3235              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3236              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3237                {                {
3238                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3239                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3240                }                }
3241              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3242              }              }
3243            }            }
3244          /* Control never gets here */          /* Control never gets here */
# Line 2881  for (;;) Line 3258  for (;;)
3258            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3259              {              {
3260              int len = 1;              int len = 1;
3261              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
3262                  {
3263                  SCHECK_PARTIAL();
3264                  break;
3265                  }
3266              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3267              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3268              if (fc == d) break;              if (fc == d) break;
# Line 2902  for (;;) Line 3283  for (;;)
3283            {            {
3284            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3285              {              {
3286              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;              if (eptr >= md->end_subject)
3287                  {
3288                  SCHECK_PARTIAL();
3289                  break;
3290                  }
3291                if (fc == md->lcc[*eptr]) break;
3292              eptr++;              eptr++;
3293              }              }
3294            if (possessive) continue;            if (possessive) continue;
# Line 2914  for (;;) Line 3300  for (;;)
3300              }              }
3301            }            }
3302    
3303          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3304          }          }
3305        /* Control never gets here */        /* Control never gets here */
3306        }        }
# Line 2933  for (;;) Line 3319  for (;;)
3319            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3320              {              {
3321              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3322              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3323              }              }
3324            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3325            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3326            }            }
3327          }          }
3328        else        else
# Line 2948  for (;;) Line 3334  for (;;)
3334            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3335              {              {
3336              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3337              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3338              }              }
3339            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3340            }            }
3341          }          }
3342    
# Line 2967  for (;;) Line 3353  for (;;)
3353              {              {
3354              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3355              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3356              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3357              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3358                {                {
3359                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3360                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3361                }                }
3362              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3363              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3364              }              }
3365            }            }
3366          else          else
# Line 2985  for (;;) Line 3371  for (;;)
3371              {              {
3372              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3373              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3374              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3375              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3376                {                {
3377                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3378                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3379                }                }
3380              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3381              }              }
3382            }            }
3383          /* Control never gets here */          /* Control never gets here */
# Line 3011  for (;;) Line 3397  for (;;)
3397            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3398              {              {
3399              int len = 1;              int len = 1;
3400              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
3401                  {
3402                  SCHECK_PARTIAL();
3403                  break;
3404                  }
3405              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3406              if (fc == d) break;              if (fc == d) break;
3407              eptr += len;              eptr += len;
# Line 3031  for (;;) Line 3421  for (;;)
3421            {            {
3422            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3423              {              {
3424              if (eptr >= md->end_subject || fc == *eptr) break;              if (eptr >= md->end_subject)
3425                  {
3426                  SCHECK_PARTIAL();
3427                  break;
3428                  }
3429                if (fc == *eptr) break;
3430              eptr++;              eptr++;
3431              }              }
3432            if (possessive) continue;            if (possessive) continue;
# Line 3043  for (;;) Line 3438  for (;;)
3438              }              }
3439            }            }
3440    
3441          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3442          }          }
3443        }        }
3444      /* Control never gets here */      /* Control never gets here */
# Line 3137  for (;;) Line 3532  for (;;)
3532          switch(prop_type)          switch(prop_type)
3533            {            {
3534            case PT_ANY:            case PT_ANY:
3535            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3536            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3537              {              {
3538              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3539                {                {
3540                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3541                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3542                }                }
3543              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3544              }              }
# Line 3155  for (;;) Line 3550  for (;;)
3550              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3551                {                {
3552                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3553                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3554                }                }
3555              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3556              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3557              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3558                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3559                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
3560                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3561              }              }
3562            break;            break;
3563    
# Line 3172  for (;;) Line 3567  for (;;)
3567              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3568                {                {
3569                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3570                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3571                }                }
3572              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3573              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3574              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3575                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3576              }              }
3577            break;            break;
3578    
# Line 3187  for (;;) Line 3582  for (;;)
3582              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3583                {                {
3584                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3585                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3586                }                }
3587              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3588              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3589              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3590                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3591              }              }
3592            break;            break;
3593    
# Line 3202  for (;;) Line 3597  for (;;)
3597              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3598                {                {
3599                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3600                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3601                }                }
3602              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3603              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3604              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3605                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3606              }              }
3607            break;            break;
3608    
3609            default:            case PT_ALNUM:
3610            RRETURN(PCRE_ERROR_INTERNAL);            for (i = 1; i <= min; i++)
           }  
         }  
   
       /* Match extended Unicode sequences. We will get here only if the  
       support is in the binary; otherwise a compile-time error occurs. */  
   
       else if (ctype == OP_EXTUNI)  
         {  
         for (i = 1; i <= min; i++)  
           {  
           if (eptr >= md->end_subject)  
3611              {              {
3612              SCHECK_PARTIAL();              if (eptr >= md->end_subject)
3613              RRETURN(MATCH_NOMATCH);                {
3614                  SCHECK_PARTIAL();
3615                  MRRETURN(MATCH_NOMATCH);
3616                  }
3617                GETCHARINCTEST(c, eptr);
3618                prop_category = UCD_CATEGORY(c);
3619                if ((prop_category == ucp_L || prop_category == ucp_N)
3620                       == prop_fail_result)
3621                  MRRETURN(MATCH_NOMATCH);
3622              }              }
3623            GETCHARINCTEST(c, eptr);            break;
3624            prop_category = UCD_CATEGORY(c);  
3625            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            case PT_SPACE:    /* Perl space */
3626            while (eptr < md->end_subject)            for (i = 1; i <= min; i++)
3627              {              {
3628              int len = 1;              if (eptr >= md->end_subject)
3629                  {
3630                  SCHECK_PARTIAL();
3631                  MRRETURN(MATCH_NOMATCH);
3632                  }
3633                GETCHARINCTEST(c, eptr);
3634                prop_category = UCD_CATEGORY(c);
3635                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3636                     c == CHAR_FF || c == CHAR_CR)
3637                       == prop_fail_result)
3638                  MRRETURN(MATCH_NOMATCH);
3639                }
3640              break;
3641    
3642              case PT_PXSPACE:  /* POSIX space */
3643              for (i = 1; i <= min; i++)
3644                {
3645                if (eptr >= md->end_subject)
3646                  {
3647                  SCHECK_PARTIAL();
3648                  MRRETURN(MATCH_NOMATCH);
3649                  }
3650                GETCHARINCTEST(c, eptr);
3651                prop_category = UCD_CATEGORY(c);
3652                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3653                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
3654                       == prop_fail_result)
3655                  MRRETURN(MATCH_NOMATCH);
3656                }
3657              break;
3658    
3659              case PT_WORD:
3660              for (i = 1; i <= min; i++)
3661                {
3662                if (eptr >= md->end_subject)
3663                  {
3664                  SCHECK_PARTIAL();
3665                  MRRETURN(MATCH_NOMATCH);
3666                  }
3667                GETCHARINCTEST(c, eptr);
3668                prop_category = UCD_CATEGORY(c);
3669                if ((prop_category == ucp_L || prop_category == ucp_N ||
3670                     c == CHAR_UNDERSCORE)
3671                       == prop_fail_result)
3672                  MRRETURN(MATCH_NOMATCH);
3673                }
3674              break;
3675    
3676              /* This should not occur */
3677    
3678              default:
3679              RRETURN(PCRE_ERROR_INTERNAL);
3680              }
3681            }
3682    
3683          /* Match extended Unicode sequences. We will get here only if the
3684          support is in the binary; otherwise a compile-time error occurs. */
3685    
3686          else if (ctype == OP_EXTUNI)
3687            {
3688            for (i = 1; i <= min; i++)
3689              {
3690              if (eptr >= md->end_subject)
3691                {
3692                SCHECK_PARTIAL();
3693                MRRETURN(MATCH_NOMATCH);
3694                }
3695              GETCHARINCTEST(c, eptr);
3696              prop_category = UCD_CATEGORY(c);
3697              if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
3698              while (eptr < md->end_subject)
3699                {
3700                int len = 1;
3701              if (!utf8) c = *eptr;              if (!utf8) c = *eptr;
3702                else { GETCHARLEN(c, eptr, len); }                else { GETCHARLEN(c, eptr, len); }
3703              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
# Line 3257  for (;;) Line 3721  for (;;)
3721            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3722              {              {
3723              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3724              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3725              }              }
3726            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3727            eptr++;            eptr++;
3728            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3729            }            }
# Line 3271  for (;;) Line 3735  for (;;)
3735            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3736              {              {
3737              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3738              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3739              }              }
3740            eptr++;            eptr++;
3741            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3279  for (;;) Line 3743  for (;;)
3743          break;          break;
3744    
3745          case OP_ANYBYTE:          case OP_ANYBYTE:
3746          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
3747          eptr += min;          eptr += min;
3748          break;          break;
3749    
# Line 3289  for (;;) Line 3753  for (;;)
3753            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3754              {              {
3755              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3756              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3757              }              }
3758            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3759            switch(c)            switch(c)
3760              {              {
3761              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3762              case 0x000d:              case 0x000d:
3763              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3764              break;              break;
# Line 3307  for (;;) Line 3771  for (;;)
3771              case 0x0085:              case 0x0085:
3772              case 0x2028:              case 0x2028:
3773              case 0x2029:              case 0x2029:
3774              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3775              break;              break;
3776              }              }
3777            }            }
# Line 3319  for (;;) Line 3783  for (;;)
3783            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3784              {              {
3785              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3786              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3787              }              }
3788            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3789            switch(c)            switch(c)
# Line 3344  for (;;) Line 3808  for (;;)
3808              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
3809              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3810              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
3811              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3812              }              }
3813            }            }
3814          break;          break;
# Line 3355  for (;;) Line 3819  for (;;)
3819            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3820              {              {
3821              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3822              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3823              }              }
3824            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3825            switch(c)            switch(c)
3826              {              {
3827              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3828              case 0x09:      /* HT */              case 0x09:      /* HT */
3829              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3830              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3391  for (;;) Line 3855  for (;;)
3855            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3856              {              {
3857              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3858              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3859              }              }
3860            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3861            switch(c)            switch(c)
# Line 3404  for (;;) Line 3868  for (;;)
3868              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3869              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
3870              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
3871              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3872              }              }
3873            }            }
3874          break;          break;
# Line 3415  for (;;) Line 3879  for (;;)
3879            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3880              {              {
3881              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3882              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3883              }              }
3884            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3885            switch(c)            switch(c)
3886              {              {
3887              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3888              case 0x0a:      /* LF */              case 0x0a:      /* LF */
3889              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3890              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3439  for (;;) Line 3903  for (;;)
3903            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3904              {              {
3905              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3906              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3907              }              }
3908            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3909            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3910              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3911            }            }
3912          break;          break;
3913    
# Line 3453  for (;;) Line 3917  for (;;)
3917            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3918              {              {
3919              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3920              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3921              }              }
3922            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3923              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3924            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
3925            }            }
3926          break;          break;
# Line 3467  for (;;) Line 3931  for (;;)
3931            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3932              {              {
3933              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3934              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3935              }              }
3936            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3937              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3938            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3939            }            }
3940          break;          break;
# Line 3481  for (;;) Line 3945  for (;;)
3945            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3946              {              {
3947              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3948              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3949              }              }
3950            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3951              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3952            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
3953            }            }
3954          break;          break;
# Line 3492  for (;;) Line 3956  for (;;)
3956          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3957          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3958            {            {
3959            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject)
3960               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))              {
3961              RRETURN(MATCH_NOMATCH);              SCHECK_PARTIAL();
3962                MRRETURN(MATCH_NOMATCH);
3963                }
3964              if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3965                MRRETURN(MATCH_NOMATCH);
3966            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3967            }            }
3968          break;          break;
# Line 3505  for (;;) Line 3973  for (;;)
3973            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3974              {              {
3975              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3976              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3977              }              }
3978            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3979              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3980            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
3981            }            }
3982          break;          break;
# Line 3531  for (;;) Line 3999  for (;;)
3999            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4000              {              {
4001              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4002              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4003              }              }
4004            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
4005            eptr++;            eptr++;
4006            }            }
4007          break;          break;
# Line 3542  for (;;) Line 4010  for (;;)
4010          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
4011            {            {
4012            SCHECK_PARTIAL();            SCHECK_PARTIAL();
4013            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
4014            }            }
4015          eptr += min;          eptr += min;
4016          break;          break;
# Line 3551  for (;;) Line 4019  for (;;)
4019          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
4020            {            {
4021            SCHECK_PARTIAL();            SCHECK_PARTIAL();
4022            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
4023            }            }
4024          eptr += min;          eptr += min;
4025          break;          break;
# Line 3562  for (;;) Line 4030  for (;;)
4030            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4031              {              {
4032              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4033              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4034              }              }
4035            switch(*eptr++)            switch(*eptr++)
4036              {              {
4037              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4038              case 0x000d:              case 0x000d:
4039              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4040              break;              break;
# Line 3576  for (;;) Line 4044  for (;;)
4044              case 0x000b:              case 0x000b:
4045              case 0x000c:              case 0x000c:
4046              case 0x0085:              case 0x0085:
4047              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4048              break;              break;
4049              }              }
4050            }            }
# Line 3588  for (;;) Line 4056  for (;;)
4056            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4057              {              {
4058              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4059              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4060              }              }
4061            switch(*eptr++)            switch(*eptr++)
4062              {              {
# Line 3596  for (;;) Line 4064  for (;;)
4064              case 0x09:      /* HT */              case 0x09:      /* HT */
4065              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4066              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4067              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4068              }              }
4069            }            }
4070          break;          break;
# Line 3607  for (;;) Line 4075  for (;;)
4075            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4076              {              {
4077              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4078              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4079              }              }
4080            switch(*eptr++)            switch(*eptr++)
4081              {              {
4082              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4083              case 0x09:      /* HT */              case 0x09:      /* HT */
4084              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4085              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3626  for (;;) Line 4094  for (;;)
4094            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4095              {              {
4096              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4097              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4098              }              }
4099            switch(*eptr++)            switch(*eptr++)
4100              {              {
# Line 3636  for (;;) Line 4104  for (;;)
4104              case 0x0c:      /* FF */              case 0x0c:      /* FF */
4105              case 0x0d:      /* CR */              case 0x0d:      /* CR */
4106              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4107              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4108              }              }
4109            }            }
4110          break;          break;
# Line 3647  for (;;) Line 4115  for (;;)
4115            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4116              {              {
4117              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4118              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4119              }              }
4120            switch(*eptr++)            switch(*eptr++)
4121              {              {
4122              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4123              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4124              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4125              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3668  for (;;) Line 4136  for (;;)
4136            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4137              {              {
4138              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4139              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4140              }              }
4141            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4142            }            }
4143          break;          break;
4144    
# Line 3680  for (;;) Line 4148  for (;;)
4148            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4149              {              {
4150              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4151              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4152              }              }
4153            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4154            }            }
4155          break;          break;
4156    
# Line 3692  for (;;) Line 4160  for (;;)
4160            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4161              {              {
4162              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4163              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4164              }              }
4165            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4166            }            }
4167          break;          break;
4168    
# Line 3704  for (;;) Line 4172  for (;;)
4172            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4173              {              {
4174              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4175              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4176              }              }
4177            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4178            }            }
4179          break;          break;
4180    
# Line 3716  for (;;) Line 4184  for (;;)
4184            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4185              {              {
4186              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4187              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4188              }              }
4189            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4190              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4191            }            }
4192          break;          break;
4193    
# Line 3729  for (;;) Line 4197  for (;;)
4197            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4198              {              {
4199              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4200              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4201              }              }
4202            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4203              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4204            }            }
4205          break;          break;
4206    
# Line 3761  for (;;) Line 4229  for (;;)
4229              {              {
4230              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
4231              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4232              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4233              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4234                {                {
4235                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4236                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4237                }                }
4238              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4239              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
4240              }              }
4241            /* Control never gets here */            /* Control never gets here */
4242    
# Line 3777  for (;;) Line 4245  for (;;)
4245              {              {
4246              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
4247              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4248              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4249              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4250                {                {
4251                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4252                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4253                }                }
4254              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4255              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4256              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4257                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
4258                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
4259                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4260              }              }
4261            /* Control never gets here */            /* Control never gets here */
4262    
# Line 3797  for (;;) Line 4265  for (;;)
4265              {              {
4266              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4267              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4268              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4269              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4270                {                {
4271                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4272                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4273                }                }
4274              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4275              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4276              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4277                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4278              }              }
4279            /* Control never gets here */            /* Control never gets here */
4280    
# Line 3815  for (;;) Line 4283  for (;;)
4283              {              {
4284              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4285              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4286              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4287              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4288                {                {
4289                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4290                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4291                }                }
4292              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4293              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4294              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4295                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4296              }              }
4297            /* Control never gets here */            /* Control never gets here */
4298    
# Line 3833  for (;;) Line 4301  for (;;)
4301              {              {
4302              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4303              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4304              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4305              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4306                {                {
4307                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4308                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4309                }                }
4310              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4311              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4312              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4313                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4314              }              }
4315            /* Control never gets here */            /* Control never gets here */
4316    
4317              case PT_ALNUM:
4318              for (fi = min;; fi++)
4319                {
4320                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM59);
4321                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4322                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4323                if (eptr >= md->end_subject)
4324                  {
4325                  SCHECK_PARTIAL();
4326                  MRRETURN(MATCH_NOMATCH);
4327                  }
4328                GETCHARINCTEST(c, eptr);
4329                prop_category = UCD_CATEGORY(c);
4330                if ((prop_category == ucp_L || prop_category == ucp_N)
4331                       == prop_fail_result)
4332                  MRRETURN(MATCH_NOMATCH);
4333                }
4334              /* Control never gets here */
4335    
4336              case PT_SPACE:    /* Perl space */
4337              for (fi = min;; fi++)
4338                {
4339                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM60);
4340                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4341                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4342                if (eptr >= md->end_subject)
4343                  {
4344                  SCHECK_PARTIAL();
4345                  MRRETURN(MATCH_NOMATCH);
4346                  }
4347                GETCHARINCTEST(c, eptr);
4348                prop_category = UCD_CATEGORY(c);
4349                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4350                     c == CHAR_FF || c == CHAR_CR)
4351                       == prop_fail_result)
4352                  MRRETURN(MATCH_NOMATCH);
4353                }
4354              /* Control never gets here */
4355    
4356              case PT_PXSPACE:  /* POSIX space */
4357              for (fi = min;; fi++)
4358                {
4359                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM61);
4360                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4361                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4362                if (eptr >= md->end_subject)
4363                  {
4364                  SCHECK_PARTIAL();
4365                  MRRETURN(MATCH_NOMATCH);
4366                  }
4367                GETCHARINCTEST(c, eptr);
4368                prop_category = UCD_CATEGORY(c);
4369                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4370                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4371                       == prop_fail_result)
4372                  MRRETURN(MATCH_NOMATCH);
4373                }
4374              /* Control never gets here */
4375    
4376              case PT_WORD:
4377              for (fi = min;; fi++)
4378                {
4379                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM62);
4380                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4381                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4382                if (eptr >= md->end_subject)
4383                  {
4384                  SCHECK_PARTIAL();
4385                  MRRETURN(MATCH_NOMATCH);
4386                  }
4387                GETCHARINCTEST(c, eptr);
4388                prop_category = UCD_CATEGORY(c);
4389                if ((prop_category == ucp_L ||
4390                     prop_category == ucp_N ||
4391                     c == CHAR_UNDERSCORE)
4392                       == prop_fail_result)
4393                  MRRETURN(MATCH_NOMATCH);
4394                }
4395              /* Control never gets here */
4396    
4397              /* This should never occur */
4398    
4399            default:            default:
4400            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4401            }            }
# Line 3860  for (;;) Line 4410  for (;;)
4410            {            {
4411            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4412            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4413            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4414            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4415              {              {
4416              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4417              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4418              }              }
4419            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4420            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4421            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
4422            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4423              {              {
4424              int len = 1;              int len = 1;
# Line 3892  for (;;) Line 4442  for (;;)
4442            {            {
4443            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4444            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4445            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4446            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4447              {              {
4448              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4449              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4450              }              }
4451            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4452              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4453            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4454            switch(ctype)            switch(ctype)
4455              {              {
# Line 3911  for (;;) Line 4461  for (;;)
4461              case OP_ANYNL:              case OP_ANYNL:
4462              switch(c)              switch(c)
4463                {                {
4464                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4465                case 0x000d:                case 0x000d:
4466                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4467                break;                break;
# Line 3923  for (;;) Line 4473  for (;;)
4473                case 0x0085:                case 0x0085:
4474                case 0x2028:                case 0x2028:
4475                case 0x2029:                case 0x2029:
4476                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4477                break;                break;
4478                }                }
4479              break;              break;
# Line 3951  for (;;) Line 4501  for (;;)
4501                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4502                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4503                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4504                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4505                }                }
4506              break;              break;
4507    
4508              case OP_HSPACE:              case OP_HSPACE:
4509              switch(c)              switch(c)
4510                {                {
4511                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4512                case 0x09:      /* HT */                case 0x09:      /* HT */
4513                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4514                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 3993  for (;;) Line 4543  for (;;)
4543                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4544                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4545                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4546                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4547                }                }
4548              break;              break;
4549    
4550              case OP_VSPACE:              case OP_VSPACE:
4551              switch(c)              switch(c)
4552                {                {
4553                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4554                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4555                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4556                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4014  for (;;) Line 4564  for (;;)
4564    
4565              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4566              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4567                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4568              break;              break;
4569    
4570              case OP_DIGIT:              case OP_DIGIT:
4571              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4572                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4573              break;              break;
4574    
4575              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4576              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4577                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4578              break;              break;
4579    
4580              case OP_WHITESPACE:              case OP_WHITESPACE:
4581              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4582                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4583              break;              break;
4584    
4585              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4586              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4587                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4588              break;              break;
4589    
4590              case OP_WORDCHAR:              case OP_WORDCHAR:
4591              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4592                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4593              break;              break;
4594    
4595              default:              default:
# Line 4055  for (;;) Line 4605  for (;;)
4605            {            {
4606            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4607            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4608            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4609            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4610              {              {
4611              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4612              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4613              }              }
4614            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4615              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4616            c = *eptr++;            c = *eptr++;
4617            switch(ctype)            switch(ctype)
4618              {              {
# Line 4074  for (;;) Line 4624  for (;;)
4624              case OP_ANYNL:              case OP_ANYNL:
4625              switch(c)              switch(c)
4626                {                {
4627                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4628                case 0x000d:                case 0x000d:
4629                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4630                break;                break;
# Line 4085  for (;;) Line 4635  for (;;)
4635                case 0x000b:                case 0x000b:
4636                case 0x000c:                case 0x000c:
4637                case 0x0085:                case 0x0085:
4638                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4639                break;                break;
4640                }                }
4641              break;              break;
# Line 4097  for (;;) Line 4647  for (;;)
4647                case 0x09:      /* HT */                case 0x09:      /* HT */
4648                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4649                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4650                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4651                }                }
4652              break;              break;
4653    
4654              case OP_HSPACE:              case OP_HSPACE:
4655              switch(c)              switch(c)
4656                {                {
4657                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4658                case 0x09:      /* HT */                case 0x09:      /* HT */
4659                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4660                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4121  for (;;) Line 4671  for (;;)
4671                case 0x0c:      /* FF */                case 0x0c:      /* FF */
4672                case 0x0d:      /* CR */                case 0x0d:      /* CR */
4673                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4674                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4675                }                }
4676              break;              break;
4677    
4678              case OP_VSPACE:              case OP_VSPACE:
4679              switch(c)              switch(c)
4680                {                {
4681                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4682                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4683                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4684                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4139  for (;;) Line 4689  for (;;)
4689              break;              break;
4690    
4691              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4692              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4693              break;              break;
4694    
4695              case OP_DIGIT:              case OP_DIGIT:
4696              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4697              break;              break;
4698    
4699              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4700              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4701              break;              break;
4702    
4703              case OP_WHITESPACE:              case OP_WHITESPACE:
4704              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4705              break;              break;
4706    
4707              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4708              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
4709              break;              break;
4710    
4711              case OP_WORDCHAR:              case OP_WORDCHAR:
4712              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
4713              break;              break;
4714    
4715              default:              default:
# Line 4187  for (;;) Line 4737  for (;;)
4737            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4738              {              {
4739              int len = 1;              int len = 1;
4740              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4741              GETCHARLEN(c, eptr, len);                {
4742                  SCHECK_PARTIAL();
4743                  break;
4744                  }
4745                GETCHARLENTEST(c, eptr, len);
4746              if (prop_fail_result) break;              if (prop_fail_result) break;
4747              eptr+= len;              eptr+= len;
4748              }              }
# Line 4198  for (;;) Line 4752  for (;;)
4752            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4753              {              {
4754              int len = 1;              int len = 1;
4755              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4756              GETCHARLEN(c, eptr, len);                {
4757                  SCHECK_PARTIAL();
4758                  break;
4759                  }
4760                GETCHARLENTEST(c, eptr, len);
4761              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4762              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4763                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
# Line 4213  for (;;) Line 4771  for (;;)
4771            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4772              {              {
4773              int len = 1;              int len = 1;
4774              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4775              GETCHARLEN(c, eptr, len);                {
4776                  SCHECK_PARTIAL();
4777                  break;
4778                  }
4779                GETCHARLENTEST(c, eptr, len);
4780              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4781              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4782                break;                break;
# Line 4226  for (;;) Line 4788  for (;;)
4788            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4789              {              {
4790              int len = 1;              int len = 1;
4791              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4792              GETCHARLEN(c, eptr, len);                {
4793                  SCHECK_PARTIAL();
4794                  break;
4795                  }
4796                GETCHARLENTEST(c, eptr, len);
4797              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4798              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4799                break;                break;
# Line 4239  for (;;) Line 4805  for (;;)
4805            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4806              {              {
4807              int len = 1;              int len = 1;
4808              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4809              GETCHARLEN(c, eptr, len);                {
4810                  SCHECK_PARTIAL();
4811                  break;
4812                  }
4813                GETCHARLENTEST(c, eptr, len);
4814              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4815              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4816                break;                break;
4817              eptr+= len;              eptr+= len;
4818              }              }
4819            break;            break;
4820    
4821              case PT_ALNUM:
4822              for (i = min; i < max; i++)
4823                {
4824                int len = 1;
4825                if (eptr >= md->end_subject)
4826                  {
4827                  SCHECK_PARTIAL();
4828                  break;
4829                  }
4830                GETCHARLENTEST(c, eptr, len);
4831                prop_category = UCD_CATEGORY(c);
4832                if ((prop_category == ucp_L || prop_category == ucp_N)
4833                     == prop_fail_result)
4834                  break;
4835                eptr+= len;
4836                }
4837              break;
4838    
4839              case PT_SPACE:    /* Perl space */
4840              for (i = min; i < max; i++)
4841                {
4842                int len = 1;
4843                if (eptr >= md->end_subject)
4844                  {
4845                  SCHECK_PARTIAL();
4846                  break;
4847                  }
4848                GETCHARLENTEST(c, eptr, len);
4849                prop_category = UCD_CATEGORY(c);
4850                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4851                     c == CHAR_FF || c == CHAR_CR)
4852                     == prop_fail_result)
4853                  break;
4854                eptr+= len;
4855                }
4856              break;
4857    
4858              case PT_PXSPACE:  /* POSIX space */
4859              for (i = min; i < max; i++)
4860                {
4861                int len = 1;
4862                if (eptr >= md->end_subject)
4863                  {
4864                  SCHECK_PARTIAL();
4865                  break;
4866                  }
4867                GETCHARLENTEST(c, eptr, len);
4868                prop_category = UCD_CATEGORY(c);
4869                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4870                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4871                     == prop_fail_result)
4872                  break;
4873                eptr+= len;
4874                }
4875              break;
4876    
4877              case PT_WORD:
4878              for (i = min; i < max; i++)
4879                {
4880                int len = 1;
4881                if (eptr >= md->end_subject)
4882                  {
4883                  SCHECK_PARTIAL();
4884                  break;
4885                  }
4886                GETCHARLENTEST(c, eptr, len);
4887                prop_category = UCD_CATEGORY(c);
4888                if ((prop_category == ucp_L || prop_category == ucp_N ||
4889                     c == CHAR_UNDERSCORE) == prop_fail_result)
4890                  break;
4891                eptr+= len;
4892                }
4893              break;
4894    
4895              default:
4896              RRETURN(PCRE_ERROR_INTERNAL);
4897            }            }
4898    
4899          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 4268  for (;;) Line 4915  for (;;)
4915          {          {
4916          for (i = min; i < max; i++)          for (i = min; i < max; i++)
4917            {            {
4918            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject)
4919                {
4920                SCHECK_PARTIAL();
4921                break;
4922                }
4923            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4924            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4925            if (prop_category == ucp_M) break;            if (prop_category == ucp_M) break;
# Line 4288  for (;;) Line 4939  for (;;)
4939          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4940    
4941          if (possessive) continue;          if (possessive) continue;
4942    
4943          for(;;)          for(;;)
4944            {            {
4945            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
# Line 4323  for (;;) Line 4975  for (;;)
4975              {              {
4976              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4977                {                {
4978                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                if (eptr >= md->end_subject)
4979                    {
4980                    SCHECK_PARTIAL();
4981                    break;
4982                    }
4983                  if (IS_NEWLINE(eptr)) break;
4984                eptr++;                eptr++;
4985                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4986                }                }
# Line 4335  for (;;) Line 4992  for (;;)
4992              {              {
4993              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4994                {                {
4995                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                if (eptr >= md->end_subject)
4996                    {
4997                    SCHECK_PARTIAL();
4998                    break;
4999                    }
5000                  if (IS_NEWLINE(eptr)) break;
5001                eptr++;                eptr++;
5002                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
5003                }                }
# Line 4347  for (;;) Line 5009  for (;;)
5009              {              {
5010              for (i = min; i < max; i++)              for (i = min; i < max; i++)
5011                {                {
5012                if (eptr >= md->end_subject) break;                if (eptr >= md->end_subject)
5013                    {
5014                    SCHECK_PARTIAL();
5015                    break;
5016                    }
5017                eptr++;                eptr++;
5018                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
5019                }                }
# Line 4360  for (;;) Line 5026  for (;;)
5026            case OP_ANYBYTE:            case OP_ANYBYTE:
5027            c = max - min;            c = max - min;
5028            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
5029              c = md->end_subject - eptr;              {
5030            eptr += c;              eptr = md->end_subject;
5031                SCHECK_PARTIAL();
5032                }
5033              else eptr += c;
5034            break;            break;
5035    
5036            case OP_ANYNL:            case OP_ANYNL:
5037            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5038              {              {
5039              int len = 1;              int len = 1;
5040              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5041                  {
5042                  SCHECK_PARTIAL();
5043                  break;
5044                  }
5045              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5046              if (c == 0x000d)              if (c == 0x000d)
5047                {                {
# Line 4393  for (;;) Line 5066  for (;;)
5066              {              {
5067              BOOL gotspace;              BOOL gotspace;
5068              int len = 1;              int len = 1;
5069              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5070                  {
5071                  SCHECK_PARTIAL();
5072                  break;
5073                  }
5074              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5075              switch(c)              switch(c)
5076                {                {
# Line 4431  for (;;) Line 5108  for (;;)
5108              {              {
5109              BOOL gotspace;              BOOL gotspace;
5110              int len = 1;              int len = 1;
5111              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5112                  {
5113                  SCHECK_PARTIAL();
5114                  break;
5115                  }
5116              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5117              switch(c)              switch(c)
5118                {                {
# Line 4455  for (;;) Line 5136  for (;;)
5136            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5137              {              {
5138              int len = 1;              int len = 1;
5139              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5140                  {
5141                  SCHECK_PARTIAL();
5142                  break;
5143                  }
5144              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5145              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
5146              eptr+= len;              eptr+= len;
# Line 4466  for (;;) Line 5151  for (;;)
5151            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5152              {              {
5153              int len = 1;              int len = 1;
5154              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5155                  {
5156                  SCHECK_PARTIAL();
5157                  break;
5158                  }
5159              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5160              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
5161              eptr+= len;              eptr+= len;
# Line 4477  for (;;) Line 5166  for (;;)
5166            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5167              {              {
5168              int len = 1;              int len = 1;
5169              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5170                  {
5171                  SCHECK_PARTIAL();
5172                  break;
5173                  }
5174              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5175              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
5176              eptr+= len;              eptr+= len;
# Line 4488  for (;;) Line 5181  for (;;)
5181            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5182              {              {
5183              int len = 1;              int len = 1;
5184              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5185                  {
5186                  SCHECK_PARTIAL();
5187                  break;
5188                  }
5189              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5190              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
5191              eptr+= len;              eptr+= len;
# Line 4499  for (;;) Line 5196  for (;;)
5196            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5197              {              {
5198              int len = 1;              int len = 1;
5199              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5200                  {
5201                  SCHECK_PARTIAL();
5202                  break;
5203                  }
5204              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5205              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
5206              eptr+= len;              eptr+= len;
# Line 4510  for (;;) Line 5211  for (;;)
5211            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5212              {              {
5213              int len = 1;              int len = 1;
5214              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5215                  {
5216                  SCHECK_PARTIAL();
5217                  break;
5218                  }
5219              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5220              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
5221              eptr+= len;              eptr+= len;
# Line 4542  for (;;) Line 5247  for (;;)
5247            case OP_ANY:            case OP_ANY:
5248            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5249              {              {
5250              if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;              if (eptr >= md->end_subject)
5251                  {
5252                  SCHECK_PARTIAL();
5253                  break;
5254                  }
5255                if (IS_NEWLINE(eptr)) break;
5256              eptr++;              eptr++;
5257              }              }
5258            break;            break;
# Line 4551  for (;;) Line 5261  for (;;)
5261            case OP_ANYBYTE:            case OP_ANYBYTE:
5262            c = max - min;            c = max - min;
5263            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
5264              c = md->end_subject - eptr;              {
5265            eptr += c;              eptr = md->end_subject;
5266                SCHECK_PARTIAL();
5267                }
5268              else eptr += c;
5269            break;            break;
5270    
5271            case OP_ANYNL:            case OP_ANYNL:
5272            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5273              {              {
5274              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5275                  {
5276                  SCHECK_PARTIAL();
5277                  break;
5278                  }
5279              c = *eptr;              c = *eptr;
5280              if (c == 0x000d)              if (c == 0x000d)
5281                {                {
# Line 4579  for (;;) Line 5296  for (;;)
5296            case OP_NOT_HSPACE:            case OP_NOT_HSPACE:
5297            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5298              {              {
5299              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5300                  {
5301                  SCHECK_PARTIAL();
5302                  break;
5303                  }
5304              c = *eptr;              c = *eptr;
5305              if (c == 0x09 || c == 0x20 || c == 0xa0) break;              if (c == 0x09 || c == 0x20 || c == 0xa0) break;
5306              eptr++;              eptr++;
# Line 4589  for (;;) Line 5310  for (;;)
5310            case OP_HSPACE:            case OP_HSPACE:
5311            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5312              {              {
5313              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5314                  {
5315                  SCHECK_PARTIAL();
5316                  break;
5317                  }
5318              c = *eptr;              c = *eptr;
5319              if (c != 0x09 && c != 0x20 && c != 0xa0) break;              if (c != 0x09 && c != 0x20 && c != 0xa0) break;
5320              eptr++;              eptr++;
# Line 4599  for (;;) Line 5324  for (;;)
5324            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
5325            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5326              {              {
5327              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5328                  {
5329                  SCHECK_PARTIAL();
5330                  break;
5331                  }
5332              c = *eptr;              c = *eptr;
5333              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
5334                break;                break;
# Line 4610  for (;;) Line 5339  for (;;)
5339            case OP_VSPACE:            case OP_VSPACE:
5340            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5341              {              {
5342              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5343                  {
5344                  SCHECK_PARTIAL();
5345                  break;
5346                  }
5347              c = *eptr;              c = *eptr;
5348              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
5349                break;                break;
# Line 4621  for (;;) Line 5354  for (;;)
5354            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
5355            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5356              {              {
5357              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) != 0)              if (eptr >= md->end_subject)
5358                  {
5359                  SCHECK_PARTIAL();
5360                break;                break;
5361                  }
5362                if ((md->ctypes[*eptr] & ctype_digit) != 0) break;
5363              eptr++;              eptr++;
5364              }              }
5365            break;            break;
# Line 4630  for (;;) Line 5367  for (;;)
5367            case OP_DIGIT:            case OP_DIGIT:
5368            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5369              {              {
5370              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) == 0)              if (eptr >= md->end_subject)
5371                  {
5372                  SCHECK_PARTIAL();
5373                break;                break;
5374                  }
5375                if ((md->ctypes[*eptr] & ctype_digit) == 0) break;
5376              eptr++;              eptr++;
5377              }              }
5378            break;            break;
# Line 4639  for (;;) Line 5380  for (;;)
5380            case OP_NOT_WHITESPACE:            case OP_NOT_WHITESPACE:
5381            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5382              {              {
5383              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) != 0)              if (eptr >= md->end_subject)
5384                  {
5385                  SCHECK_PARTIAL();
5386                break;                break;
5387                  }
5388                if ((md->ctypes[*eptr] & ctype_space) != 0) break;
5389              eptr++;              eptr++;
5390              }              }
5391            break;            break;
# Line 4648  for (;;) Line 5393  for (;;)
5393            case OP_WHITESPACE:            case OP_WHITESPACE:
5394            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5395              {              {
5396              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) == 0)              if (eptr >= md->end_subject)
5397                  {
5398                  SCHECK_PARTIAL();
5399                break;                break;
5400                  }
5401                if ((md->ctypes[*eptr] & ctype_space) == 0) break;
5402              eptr++;              eptr++;
5403              }              }
5404            break;            break;
# Line 4657  for (;;) Line 5406  for (;;)
5406            case OP_NOT_WORDCHAR:            case OP_NOT_WORDCHAR:
5407            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5408              {              {
5409              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) != 0)              if (eptr >= md->end_subject)
5410                  {
5411                  SCHECK_PARTIAL();
5412                break;                break;
5413                  }
5414                if ((md->ctypes[*eptr] & ctype_word) != 0) break;
5415              eptr++;              eptr++;
5416              }              }
5417            break;            break;
# Line 4666  for (;;) Line 5419  for (;;)
5419            case OP_WORDCHAR:            case OP_WORDCHAR:
5420            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5421              {              {
5422              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) == 0)              if (eptr >= md->end_subject)
5423                  {
5424                  SCHECK_PARTIAL();
5425                break;                break;
5426                  }
5427                if ((md->ctypes[*eptr] & ctype_word) == 0) break;
5428              eptr++;              eptr++;
5429              }              }
5430            break;            break;
# Line 4689  for (;;) Line 5446  for (;;)
5446    
5447        /* Get here if we can't make it match with any permitted repetitions */        /* Get here if we can't make it match with any permitted repetitions */
5448    
5449        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
5450        }        }
5451      /* Control never gets here */      /* Control never gets here */
5452    
# Line 4722  switch (frame->Xwhere) Line 5479  switch (frame->Xwhere)
5479    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
5480    LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)    LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
5481    LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)    LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
5482    LBL(53) LBL(54)    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58)
5483  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
5484    LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)    LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
5485    LBL(32) LBL(34) LBL(42) LBL(46)    LBL(32) LBL(34) LBL(42) LBL(46)
5486  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
5487    LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)    LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
5488      LBL(59) LBL(60) LBL(61) LBL(62)
5489  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
5490  #endif  /* SUPPORT_UTF8 */  #endif  /* SUPPORT_UTF8 */
5491    default:    default:
# Line 4862  if (re == NULL || subject == NULL || Line 5620  if (re == NULL || subject == NULL ||
5620     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
5621  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
5622    
5623    /* This information is for finding all the numbers associated with a given
5624    name, for condition testing. */
5625    
5626    md->name_table = (uschar *)re + re->name_table_offset;
5627    md->name_count = re->name_count;
5628    md->name_entry_size = re->name_entry_size;
5629    
5630  /* Fish out the optional data from the extra_data structure, first setting  /* Fish out the optional data from the extra_data structure, first setting
5631  the default values. */  the default values. */
5632    
# Line 4924  end_subject = md->end_subject; Line 5689  end_subject = md->end_subject;
5689    
5690  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
5691  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
5692    md->use_ucp = (re->options & PCRE_UCP) != 0;
5693  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
5694    
5695  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
# Line 4933  md->notempty_atstart = (options & PCRE_N Line 5699  md->notempty_atstart = (options & PCRE_N
5699  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5700                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5701  md->hitend = FALSE;  md->hitend = FALSE;
5702    md->mark = NULL;                        /* In case never set */
5703    
5704  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
5705    
# Line 5094  if (!anchored) Line 5861  if (!anchored)
5861      }      }
5862    else    else
5863      if (!startline && study != NULL &&      if (!startline && study != NULL &&
5864        (study->options & PCRE_STUDY_MAPPED) != 0)        (study->flags & PCRE_STUDY_MAPPED) != 0)
5865          start_bits = study->start_bits;          start_bits = study->start_bits;
5866    }    }
5867    
# Line 5211  for(;;) Line 5978  for(;;)
5978        while (start_match < end_subject)        while (start_match < end_subject)
5979          {          {
5980          register unsigned int c = *start_match;          register unsigned int c = *start_match;
5981          if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++;          if ((start_bits[c/8] & (1 << (c&7))) == 0)
5982            else break;            {
5983              start_match++;
5984    #ifdef SUPPORT_UTF8
5985              if (utf8)
5986                while(start_match < end_subject && (*start_match & 0xc0) == 0x80)