/[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 427 by ph10, Fri Aug 28 09:55:54 2009 UTC revision 530 by ph10, Tue Jun 1 13:42:06 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 288  argument of match(), which never changes Line 299  argument of match(), which never changes
299    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
300    newframe->Xecode = rb;\    newframe->Xecode = rb;\
301    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
302      newframe->Xmarkptr = markptr;\
303    newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
304    newframe->Xims = re;\    newframe->Xims = re;\
305    newframe->Xeptrb = rf;\    newframe->Xeptrb = rf;\
# Line 303  argument of match(), which never changes Line 315  argument of match(), which never changes
315    
316  #define RRETURN(ra)\  #define RRETURN(ra)\
317    {\    {\
318    heapframe *newframe = frame;\    heapframe *oldframe = frame;\
319    frame = newframe->Xprevframe;\    frame = oldframe->Xprevframe;\
320    (pcre_stack_free)(newframe);\    (pcre_stack_free)(oldframe);\
321    if (frame != NULL)\    if (frame != NULL)\
322      {\      {\
323      rrc = ra;\      rrc = ra;\
# Line 325  typedef struct heapframe { Line 337  typedef struct heapframe {
337    USPTR Xeptr;    USPTR Xeptr;
338    const uschar *Xecode;    const uschar *Xecode;
339    USPTR Xmstart;    USPTR Xmstart;
340      USPTR Xmarkptr;
341    int Xoffset_top;    int Xoffset_top;
342    long int Xims;    long int Xims;
343    eptrblock *Xeptrb;    eptrblock *Xeptrb;
# Line 408  immediately. The second one is used when Line 421  immediately. The second one is used when
421  the subject. */  the subject. */
422    
423  #define CHECK_PARTIAL()\  #define CHECK_PARTIAL()\
424    if (md->partial && eptr >= md->end_subject && eptr > mstart)\    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
425      {\      {\
426      md->hitend = TRUE;\      md->hitend = TRUE;\
427      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
428      }      }
429    
430  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
431    if (md->partial && eptr > mstart)\    if (md->partial != 0 && eptr > mstart)\
432      {\      {\
433      md->hitend = TRUE;\      md->hitend = TRUE;\
434      md->hitend = TRUE;\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
     if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\  
435      }      }
436    
437    
# Line 433  Arguments: Line 445  Arguments:
445     ecode       pointer to current position in compiled code     ecode       pointer to current position in compiled code
446     mstart      pointer to the current match start position (can be modified     mstart      pointer to the current match start position (can be modified
447                   by encountering \K)                   by encountering \K)
448       markptr     pointer to the most recent MARK name, or NULL
449     offset_top  current top pointer     offset_top  current top pointer
450     md          pointer to "static" info for the match     md          pointer to "static" info for the match
451     ims         current /i, /m, and /s options     ims         current /i, /m, and /s options
# Line 446  Arguments: Line 459  Arguments:
459    
460  Returns:       MATCH_MATCH if matched            )  these values are >= 0  Returns:       MATCH_MATCH if matched            )  these values are >= 0
461                 MATCH_NOMATCH if failed to match  )                 MATCH_NOMATCH if failed to match  )
462                   a negative MATCH_xxx value for PRUNE, SKIP, etc
463                 a negative PCRE_ERROR_xxx value if aborted by an error condition                 a negative PCRE_ERROR_xxx value if aborted by an error condition
464                   (e.g. stopped by repeated call or recursion limit)                   (e.g. stopped by repeated call or recursion limit)
465  */  */
466    
467  static int  static int
468  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
469    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,
470    int flags, unsigned int rdepth)    eptrblock *eptrb, int flags, unsigned int rdepth)
471  {  {
472  /* 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,
473  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 481  frame->Xprevframe = NULL; /* Line 495  frame->Xprevframe = NULL; /*
495  frame->Xeptr = eptr;  frame->Xeptr = eptr;
496  frame->Xecode = ecode;  frame->Xecode = ecode;
497  frame->Xmstart = mstart;  frame->Xmstart = mstart;
498    frame->Xmarkptr = markptr;
499  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
500  frame->Xims = ims;  frame->Xims = ims;
501  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
# Line 496  HEAP_RECURSE: Line 511  HEAP_RECURSE:
511  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
512  #define ecode              frame->Xecode  #define ecode              frame->Xecode
513  #define mstart             frame->Xmstart  #define mstart             frame->Xmstart
514    #define markptr            frame->Xmarkptr
515  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
516  #define ims                frame->Xims  #define ims                frame->Xims
517  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
# Line 623  TAIL_RECURSE: Line 639  TAIL_RECURSE:
639  /* 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
640  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
641  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()
642  and a "return", respectively (possibly with some debugging if DEBUG is  and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
643  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
644  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,
645  however, impact performance when true recursion is being used. */  however, impact performance when true recursion is being used. */
# Line 665  for (;;) Line 681  for (;;)
681    minimize = possessive = FALSE;    minimize = possessive = FALSE;
682    op = *ecode;    op = *ecode;
683    
   /* For partial matching, remember if we ever hit the end of the subject after  
   matching at least one subject character. This code is now wrapped in a macro  
   because it appears several times below. */  
   
   CHECK_PARTIAL();  
   
684    switch(op)    switch(op)
685      {      {
686        case OP_MARK:
687        markptr = ecode + 2;
688        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
689          ims, eptrb, flags, RM55);
690    
691        /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
692        argument, and we must check whether that argument matches this MARK's
693        argument. It is passed back in md->start_match_ptr (an overloading of that
694        variable). If it does match, we reset that variable to the current subject
695        position and return MATCH_SKIP. Otherwise, pass back the return code
696        unaltered. */
697    
698        if (rrc == MATCH_SKIP_ARG &&
699            strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
700          {
701          md->start_match_ptr = eptr;
702          RRETURN(MATCH_SKIP);
703          }
704    
705        if (md->mark == NULL) md->mark = markptr;
706        RRETURN(rrc);
707    
708      case OP_FAIL:      case OP_FAIL:
709      RRETURN(MATCH_NOMATCH);      MRRETURN(MATCH_NOMATCH);
710    
711        case OP_COMMIT:
712        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
713          ims, eptrb, flags, RM52);
714        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
715        MRRETURN(MATCH_COMMIT);
716    
717      case OP_PRUNE:      case OP_PRUNE:
718      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
719        ims, eptrb, flags, RM51);        ims, eptrb, flags, RM51);
720      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
721      RRETURN(MATCH_PRUNE);      MRRETURN(MATCH_PRUNE);
722    
723      case OP_COMMIT:      case OP_PRUNE_ARG:
724      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
725        ims, eptrb, flags, RM52);        ims, eptrb, flags, RM56);
726      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
727      RRETURN(MATCH_COMMIT);      md->mark = ecode + 2;
728        RRETURN(MATCH_PRUNE);
729    
730      case OP_SKIP:      case OP_SKIP:
731      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
732        ims, eptrb, flags, RM53);        ims, eptrb, flags, RM53);
733      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
734      md->start_match_ptr = eptr;   /* Pass back current position */      md->start_match_ptr = eptr;   /* Pass back current position */
735      RRETURN(MATCH_SKIP);      MRRETURN(MATCH_SKIP);
736    
737        case OP_SKIP_ARG:
738        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
739          ims, eptrb, flags, RM57);
740        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
741    
742        /* Pass back the current skip name by overloading md->start_match_ptr and
743        returning the special MATCH_SKIP_ARG return code. This will either be
744        caught by a matching MARK, or get to the top, where it is treated the same
745        as PRUNE. */
746    
747        md->start_match_ptr = ecode + 2;
748        RRETURN(MATCH_SKIP_ARG);
749    
750      case OP_THEN:      case OP_THEN:
751      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
752        ims, eptrb, flags, RM54);        ims, eptrb, flags, RM54);
753      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
754        MRRETURN(MATCH_THEN);
755    
756        case OP_THEN_ARG:
757        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
758          ims, eptrb, flags, RM58);
759        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
760        md->mark = ecode + 2;
761      RRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
762    
763      /* 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 720  for (;;) Line 779  for (;;)
779      number = GET2(ecode, 1+LINK_SIZE);      number = GET2(ecode, 1+LINK_SIZE);
780      offset = number << 1;      offset = number << 1;
781    
782  #ifdef DEBUG  #ifdef PCRE_DEBUG
783      printf("start bracket %d\n", number);      printf("start bracket %d\n", number);
784      printf("subject=");      printf("subject=");
785      pchars(eptr, 16, TRUE, md);      pchars(eptr, 16, TRUE, md);
# Line 735  for (;;) Line 794  for (;;)
794        save_capture_last = md->capture_last;        save_capture_last = md->capture_last;
795    
796        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
797        md->offset_vector[md->offset_end - number] = eptr - md->start_subject;        md->offset_vector[md->offset_end - number] =
798            (int)(eptr - md->start_subject);
799    
800        flags = (op == OP_SCBRA)? match_cbegroup : 0;        flags = (op == OP_SCBRA)? match_cbegroup : 0;
801        do        do
# Line 754  for (;;) Line 814  for (;;)
814        md->offset_vector[offset+1] = save_offset2;        md->offset_vector[offset+1] = save_offset2;
815        md->offset_vector[md->offset_end - number] = save_offset3;        md->offset_vector[md->offset_end - number] = save_offset3;
816    
817          if (rrc != MATCH_THEN) md->mark = markptr;
818        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
819        }        }
820    
# Line 793  for (;;) Line 854  for (;;)
854    
855          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
856            eptrb, flags, RM48);            eptrb, flags, RM48);
857            if (rrc == MATCH_NOMATCH) md->mark = markptr;
858          RRETURN(rrc);          RRETURN(rrc);
859          }          }
860    
# Line 828  for (;;) Line 890  for (;;)
890          cb.callout_number   = ecode[LINK_SIZE+2];          cb.callout_number   = ecode[LINK_SIZE+2];
891          cb.offset_vector    = md->offset_vector;          cb.offset_vector    = md->offset_vector;
892          cb.subject          = (PCRE_SPTR)md->start_subject;          cb.subject          = (PCRE_SPTR)md->start_subject;
893          cb.subject_length   = md->end_subject - md->start_subject;          cb.subject_length   = (int)(md->end_subject - md->start_subject);
894          cb.start_match      = mstart - md->start_subject;          cb.start_match      = (int)(mstart - md->start_subject);
895          cb.current_position = eptr - md->start_subject;          cb.current_position = (int)(eptr - md->start_subject);
896          cb.pattern_position = GET(ecode, LINK_SIZE + 3);          cb.pattern_position = GET(ecode, LINK_SIZE + 3);
897          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
898          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
899          cb.capture_last     = md->capture_last;          cb.capture_last     = md->capture_last;
900          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
901          if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);          if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
902          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
903          }          }
904        ecode += _pcre_OP_lengths[OP_CALLOUT];        ecode += _pcre_OP_lengths[OP_CALLOUT];
# Line 846  for (;;) Line 908  for (;;)
908    
909      /* Now see what the actual condition is */      /* Now see what the actual condition is */
910    
911      if (condcode == OP_RREF)         /* Recursion test */      if (condcode == OP_RREF || condcode == OP_NRREF)    /* Recursion test */
912        {        {
913        offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/        if (md->recursive == NULL)                /* Not recursing => FALSE */
914        condition = md->recursive != NULL &&          {
915          (offset == RREF_ANY || offset == md->recursive->group_num);          condition = FALSE;
916        ecode += condition? 3 : GET(ecode, 1);          ecode += GET(ecode, 1);
917            }
918          else
919            {
920            int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
921            condition =  (recno == RREF_ANY || recno == md->recursive->group_num);
922    
923            /* If the test is for recursion into a specific subpattern, and it is
924            false, but the test was set up by name, scan the table to see if the
925            name refers to any other numbers, and test them. The condition is true
926            if any one is set. */
927    
928            if (!condition && condcode == OP_NRREF && recno != RREF_ANY)
929              {
930              uschar *slotA = md->name_table;
931              for (i = 0; i < md->name_count; i++)
932                {
933                if (GET2(slotA, 0) == recno) break;
934                slotA += md->name_entry_size;
935                }
936    
937              /* Found a name for the number - there can be only one; duplicate
938              names for different numbers are allowed, but not vice versa. First
939              scan down for duplicates. */
940    
941              if (i < md->name_count)
942                {
943                uschar *slotB = slotA;
944                while (slotB > md->name_table)
945                  {
946                  slotB -= md->name_entry_size;
947                  if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
948                    {
949                    condition = GET2(slotB, 0) == md->recursive->group_num;
950                    if (condition) break;
951                    }
952                  else break;
953                  }
954    
955                /* Scan up for duplicates */
956    
957                if (!condition)
958                  {
959                  slotB = slotA;
960                  for (i++; i < md->name_count; i++)
961                    {
962                    slotB += md->name_entry_size;
963                    if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
964                      {
965                      condition = GET2(slotB, 0) == md->recursive->group_num;
966                      if (condition) break;
967                      }
968                    else break;
969                    }
970                  }
971                }
972              }
973    
974            /* Chose branch according to the condition */
975    
976            ecode += condition? 3 : GET(ecode, 1);
977            }
978        }        }
979    
980      else if (condcode == OP_CREF)    /* Group used test */      else if (condcode == OP_CREF || condcode == OP_NCREF)  /* Group used test */
981        {        {
982        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
983        condition = offset < offset_top && md->offset_vector[offset] >= 0;        condition = offset < offset_top && md->offset_vector[offset] >= 0;
984    
985          /* If the numbered capture is unset, but the reference was by name,
986          scan the table to see if the name refers to any other numbers, and test
987          them. The condition is true if any one is set. This is tediously similar
988          to the code above, but not close enough to try to amalgamate. */
989    
990          if (!condition && condcode == OP_NCREF)
991            {
992            int refno = offset >> 1;
993            uschar *slotA = md->name_table;
994    
995            for (i = 0; i < md->name_count; i++)
996              {
997              if (GET2(slotA, 0) == refno) break;
998              slotA += md->name_entry_size;
999              }
1000    
1001            /* Found a name for the number - there can be only one; duplicate names
1002            for different numbers are allowed, but not vice versa. First scan down
1003            for duplicates. */
1004    
1005            if (i < md->name_count)
1006              {
1007              uschar *slotB = slotA;
1008              while (slotB > md->name_table)
1009                {
1010                slotB -= md->name_entry_size;
1011                if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1012                  {
1013                  offset = GET2(slotB, 0) << 1;
1014                  condition = offset < offset_top &&
1015                    md->offset_vector[offset] >= 0;
1016                  if (condition) break;
1017                  }
1018                else break;
1019                }
1020    
1021              /* Scan up for duplicates */
1022    
1023              if (!condition)
1024                {
1025                slotB = slotA;
1026                for (i++; i < md->name_count; i++)
1027                  {
1028                  slotB += md->name_entry_size;
1029                  if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1030                    {
1031                    offset = GET2(slotB, 0) << 1;
1032                    condition = offset < offset_top &&
1033                      md->offset_vector[offset] >= 0;
1034                    if (condition) break;
1035                    }
1036                  else break;
1037                  }
1038                }
1039              }
1040            }
1041    
1042          /* Chose branch according to the condition */
1043    
1044        ecode += condition? 3 : GET(ecode, 1);        ecode += condition? 3 : GET(ecode, 1);
1045        }        }
1046    
# Line 918  for (;;) Line 1101  for (;;)
1101      break;      break;
1102    
1103    
1104        /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
1105        to close any currently open capturing brackets. */
1106    
1107        case OP_CLOSE:
1108        number = GET2(ecode, 1);
1109        offset = number << 1;
1110    
1111    #ifdef PCRE_DEBUG
1112          printf("end bracket %d at *ACCEPT", number);
1113          printf("\n");
1114    #endif
1115    
1116        md->capture_last = number;
1117        if (offset >= md->offset_max) md->offset_overflow = TRUE; else
1118          {
1119          md->offset_vector[offset] =
1120            md->offset_vector[md->offset_end - number];
1121          md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1122          if (offset_top <= offset) offset_top = offset + 2;
1123          }
1124        ecode += 3;
1125        break;
1126    
1127    
1128      /* 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
1129      recursion, we should restore the offsets appropriately and continue from      recursion, we should restore the offsets appropriately and continue from
1130      after the call. */      after the call. */
# Line 931  for (;;) Line 1138  for (;;)
1138        md->recursive = rec->prevrec;        md->recursive = rec->prevrec;
1139        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
1140          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
1141        mstart = rec->save_start;        offset_top = rec->save_offset_top;
1142        ims = original_ims;        ims = original_ims;
1143        ecode = rec->after_call;        ecode = rec->after_call;
1144        break;        break;
1145        }        }
1146    
1147      /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty      /* Otherwise, if we have matched an empty string, fail if PCRE_NOTEMPTY is
1148      string - backtracking will then try other alternatives, if any. */      set, or if PCRE_NOTEMPTY_ATSTART is set and we have matched at the start of
1149        the subject. In both cases, backtracking will then try other alternatives,
1150        if any. */
1151    
1152        if (eptr == mstart &&
1153            (md->notempty ||
1154              (md->notempty_atstart &&
1155                mstart == md->start_subject + md->start_offset)))
1156          MRRETURN(MATCH_NOMATCH);
1157    
1158        /* Otherwise, we have a match. */
1159    
     if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);  
1160      md->end_match_ptr = eptr;           /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
1161      md->end_offset_top = offset_top;    /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
1162      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
1163      RRETURN(MATCH_MATCH);  
1164        /* For some reason, the macros don't work properly if an expression is
1165        given as the argument to MRRETURN when the heap is in use. */
1166    
1167        rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1168        MRRETURN(rrc);
1169    
1170      /* Change option settings */      /* Change option settings */
1171    
# Line 966  for (;;) Line 1187  for (;;)
1187        {        {
1188        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1189          RM4);          RM4);
1190        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1191            {
1192            mstart = md->start_match_ptr;   /* In case \K reset it */
1193            break;
1194            }
1195        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1196        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1197        }        }
1198      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1199      if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);      if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
1200    
1201      /* If checking an assertion for a condition, return MATCH_MATCH. */      /* If checking an assertion for a condition, return MATCH_MATCH. */
1202    
# Line 985  for (;;) Line 1210  for (;;)
1210      offset_top = md->end_offset_top;      offset_top = md->end_offset_top;
1211      continue;      continue;
1212    
1213      /* Negative assertion: all branches must fail to match */      /* Negative assertion: all branches must fail to match. Encountering SKIP,
1214        PRUNE, or COMMIT means we must assume failure without checking subsequent
1215        branches. */
1216    
1217      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1218      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
# Line 993  for (;;) Line 1220  for (;;)
1220        {        {
1221        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1222          RM5);          RM5);
1223        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
1224          if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1225            {
1226            do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1227            break;
1228            }
1229        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1230        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1231        }        }
# Line 1017  for (;;) Line 1249  for (;;)
1249        while (i-- > 0)        while (i-- > 0)
1250          {          {
1251          eptr--;          eptr--;
1252          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1253          BACKCHAR(eptr);          BACKCHAR(eptr);
1254          }          }
1255        }        }
# Line 1028  for (;;) Line 1260  for (;;)
1260    
1261        {        {
1262        eptr -= GET(ecode, 1);        eptr -= GET(ecode, 1);
1263        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1264        }        }
1265    
1266      /* Skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
1267    
1268        if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
1269      ecode += 1 + LINK_SIZE;      ecode += 1 + LINK_SIZE;
1270      break;      break;
1271    
# Line 1048  for (;;) Line 1281  for (;;)
1281        cb.callout_number   = ecode[1];        cb.callout_number   = ecode[1];
1282        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
1283        cb.subject          = (PCRE_SPTR)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
1284        cb.subject_length   = md->end_subject - md->start_subject;        cb.subject_length   = (int)(md->end_subject - md->start_subject);
1285        cb.start_match      = mstart - md->start_subject;        cb.start_match      = (int)(mstart - md->start_subject);
1286        cb.current_position = eptr - md->start_subject;        cb.current_position = (int)(eptr - md->start_subject);
1287        cb.pattern_position = GET(ecode, 2);        cb.pattern_position = GET(ecode, 2);
1288        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1289        cb.capture_top      = offset_top/2;        cb.capture_top      = offset_top/2;
1290        cb.capture_last     = md->capture_last;        cb.capture_last     = md->capture_last;
1291        cb.callout_data     = md->callout_data;        cb.callout_data     = md->callout_data;
1292        if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);        if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1293        if (rrc < 0) RRETURN(rrc);        if (rrc < 0) RRETURN(rrc);
1294        }        }
1295      ecode += 2 + 2*LINK_SIZE;      ecode += 2 + 2*LINK_SIZE;
# Line 1111  for (;;) Line 1344  for (;;)
1344    
1345        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1346              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
1347        new_recursive.save_start = mstart;        new_recursive.save_offset_top = offset_top;
       mstart = eptr;  
1348    
1349        /* 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
1350        restore the offset and recursion data. */        restore the offset and recursion data. */
# Line 1123  for (;;) Line 1355  for (;;)
1355          {          {
1356          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1357            md, ims, eptrb, flags, RM6);            md, ims, eptrb, flags, RM6);
1358          if (rrc == MATCH_MATCH)          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1359            {            {
1360            DPRINTF(("Recursion matched\n"));            DPRINTF(("Recursion matched\n"));
1361            md->recursive = new_recursive.prevrec;            md->recursive = new_recursive.prevrec;
1362            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1363              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1364            RRETURN(MATCH_MATCH);            MRRETURN(MATCH_MATCH);
1365            }            }
1366          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1367            {            {
# Line 1150  for (;;) Line 1382  for (;;)
1382        md->recursive = new_recursive.prevrec;        md->recursive = new_recursive.prevrec;
1383        if (new_recursive.offset_save != stacksave)        if (new_recursive.offset_save != stacksave)
1384          (pcre_free)(new_recursive.offset_save);          (pcre_free)(new_recursive.offset_save);
1385        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1386        }        }
1387      /* Control never reaches here */      /* Control never reaches here */
1388    
# Line 1159  for (;;) Line 1391  for (;;)
1391      a move back into the brackets. Friedl calls these "atomic" subpatterns.      a move back into the brackets. Friedl calls these "atomic" subpatterns.
1392      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
1393      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
1394      the end of a normal bracket, leaving the subject pointer. */      the end of a normal bracket, leaving the subject pointer, but resetting
1395        the start-of-match value in case it was changed by \K. */
1396    
1397      case OP_ONCE:      case OP_ONCE:
1398      prev = ecode;      prev = ecode;
# Line 1168  for (;;) Line 1401  for (;;)
1401      do      do
1402        {        {
1403        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);
1404        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
1405            {
1406            mstart = md->start_match_ptr;
1407            break;
1408            }
1409        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1410        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1411        }        }
# Line 1287  for (;;) Line 1524  for (;;)
1524        }        }
1525      else saved_eptr = NULL;      else saved_eptr = NULL;
1526    
1527      /* 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
1528      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
1529      assertions. Do this also for the "once" (atomic) groups. */      use by positive assertions. We also need to record the match start in case
1530        it was changed by \K. */
1531    
1532      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1533          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
# Line 1297  for (;;) Line 1535  for (;;)
1535        {        {
1536        md->end_match_ptr = eptr;      /* For ONCE */        md->end_match_ptr = eptr;      /* For ONCE */
1537        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
1538        RRETURN(MATCH_MATCH);        md->start_match_ptr = mstart;
1539          MRRETURN(MATCH_MATCH);
1540        }        }
1541    
1542      /* 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 1311  for (;;) Line 1550  for (;;)
1550        number = GET2(prev, 1+LINK_SIZE);        number = GET2(prev, 1+LINK_SIZE);
1551        offset = number << 1;        offset = number << 1;
1552    
1553  #ifdef DEBUG  #ifdef PCRE_DEBUG
1554        printf("end bracket %d", number);        printf("end bracket %d", number);
1555        printf("\n");        printf("\n");
1556  #endif  #endif
# Line 1321  for (;;) Line 1560  for (;;)
1560          {          {
1561          md->offset_vector[offset] =          md->offset_vector[offset] =
1562            md->offset_vector[md->offset_end - number];            md->offset_vector[md->offset_end - number];
1563          md->offset_vector[offset+1] = eptr - md->start_subject;          md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1564          if (offset_top <= offset) offset_top = offset + 2;          if (offset_top <= offset) offset_top = offset + 2;
1565          }          }
1566    
# Line 1333  for (;;) Line 1572  for (;;)
1572          recursion_info *rec = md->recursive;          recursion_info *rec = md->recursive;
1573          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1574          md->recursive = rec->prevrec;          md->recursive = rec->prevrec;
         mstart = rec->save_start;  
1575          memcpy(md->offset_vector, rec->offset_save,          memcpy(md->offset_vector, rec->offset_save,
1576            rec->saved_max * sizeof(int));            rec->saved_max * sizeof(int));
1577            offset_top = rec->save_offset_top;
1578          ecode = rec->after_call;          ecode = rec->after_call;
1579          ims = original_ims;          ims = original_ims;
1580          break;          break;
# Line 1392  for (;;) Line 1631  for (;;)
1631      /* Start of subject unless notbol, or after internal newline if multiline */      /* Start of subject unless notbol, or after internal newline if multiline */
1632    
1633      case OP_CIRC:      case OP_CIRC:
1634      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1635      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1636        {        {
1637        if (eptr != md->start_subject &&        if (eptr != md->start_subject &&
1638            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1639          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1640        ecode++;        ecode++;
1641        break;        break;
1642        }        }
# Line 1406  for (;;) Line 1645  for (;;)
1645      /* Start of subject assertion */      /* Start of subject assertion */
1646    
1647      case OP_SOD:      case OP_SOD:
1648      if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
1649      ecode++;      ecode++;
1650      break;      break;
1651    
1652      /* Start of match assertion */      /* Start of match assertion */
1653    
1654      case OP_SOM:      case OP_SOM:
1655      if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
1656      ecode++;      ecode++;
1657      break;      break;
1658    
# Line 1431  for (;;) Line 1670  for (;;)
1670      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1671        {        {
1672        if (eptr < md->end_subject)        if (eptr < md->end_subject)
1673          { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }          { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
1674        else        else
1675          { if (md->noteol) RRETURN(MATCH_NOMATCH); }          { if (md->noteol) MRRETURN(MATCH_NOMATCH); }
1676        ecode++;        ecode++;
1677        break;        break;
1678        }        }
1679      else      else
1680        {        {
1681        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) MRRETURN(MATCH_NOMATCH);
1682        if (!md->endonly)        if (!md->endonly)
1683          {          {
1684          if (eptr != md->end_subject &&          if (eptr != md->end_subject &&
1685              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1686            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
1687          ecode++;          ecode++;
1688          break;          break;
1689          }          }
# Line 1454  for (;;) Line 1693  for (;;)
1693      /* End of subject assertion (\z) */      /* End of subject assertion (\z) */
1694    
1695      case OP_EOD:      case OP_EOD:
1696      if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
1697      ecode++;      ecode++;
1698      break;      break;
1699    
# Line 1463  for (;;) Line 1702  for (;;)
1702      case OP_EODN:      case OP_EODN:
1703      if (eptr != md->end_subject &&      if (eptr != md->end_subject &&
1704          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1705        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1706      ecode++;      ecode++;
1707      break;      break;
1708    
# Line 1475  for (;;) Line 1714  for (;;)
1714    
1715        /* Find out if the previous and current characters are "word" characters.        /* Find out if the previous and current characters are "word" characters.
1716        It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to        It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
1717        be "non-word" characters. */        be "non-word" characters. Remember the earliest consulted character for
1718          partial matching. */
1719    
1720  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
1721        if (utf8)        if (utf8)
1722          {          {
1723            /* Get status of previous character */
1724    
1725          if (eptr == md->start_subject) prev_is_word = FALSE; else          if (eptr == md->start_subject) prev_is_word = FALSE; else
1726            {            {
1727            USPTR lastptr = eptr - 1;            USPTR lastptr = eptr - 1;
1728            while((*lastptr & 0xc0) == 0x80) lastptr--;            while((*lastptr & 0xc0) == 0x80) lastptr--;
1729              if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
1730            GETCHAR(c, lastptr);            GETCHAR(c, lastptr);
1731    #ifdef SUPPORT_UCP
1732              if (md->use_ucp)
1733                {
1734                if (c == '_') prev_is_word = TRUE; else
1735                  {
1736                  int cat = UCD_CATEGORY(c);
1737                  prev_is_word = (cat == ucp_L || cat == ucp_N);
1738                  }
1739                }
1740              else
1741    #endif
1742            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1743            }            }
1744          if (eptr >= md->end_subject) cur_is_word = FALSE; else  
1745            /* Get status of next character */
1746    
1747            if (eptr >= md->end_subject)
1748              {
1749              SCHECK_PARTIAL();
1750              cur_is_word = FALSE;
1751              }
1752            else
1753            {            {
1754            GETCHAR(c, eptr);            GETCHAR(c, eptr);
1755    #ifdef SUPPORT_UCP
1756              if (md->use_ucp)
1757                {
1758                if (c == '_') cur_is_word = TRUE; else
1759                  {
1760                  int cat = UCD_CATEGORY(c);
1761                  cur_is_word = (cat == ucp_L || cat == ucp_N);
1762                  }
1763                }
1764              else
1765    #endif
1766            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;            cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
1767            }            }
1768          }          }
1769        else        else
1770  #endif  #endif
1771    
1772        /* More streamlined when not in UTF-8 mode */        /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
1773          consistency with the behaviour of \w we do use it in this case. */
1774    
1775          {          {
1776          prev_is_word = (eptr != md->start_subject) &&          /* Get status of previous character */
1777            ((md->ctypes[eptr[-1]] & ctype_word) != 0);  
1778          cur_is_word = (eptr < md->end_subject) &&          if (eptr == md->start_subject) prev_is_word = FALSE; else
1779            ((md->ctypes[*eptr] & ctype_word) != 0);            {
1780              if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
1781    #ifdef SUPPORT_UCP
1782              if (md->use_ucp)
1783                {
1784                c = eptr[-1];
1785                if (c == '_') prev_is_word = TRUE; else
1786                  {
1787                  int cat = UCD_CATEGORY(c);
1788                  prev_is_word = (cat == ucp_L || cat == ucp_N);
1789                  }
1790                }
1791              else
1792    #endif
1793              prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);
1794              }
1795    
1796            /* Get status of next character */
1797    
1798            if (eptr >= md->end_subject)
1799              {
1800              SCHECK_PARTIAL();
1801              cur_is_word = FALSE;
1802              }
1803            else
1804    #ifdef SUPPORT_UCP
1805            if (md->use_ucp)
1806              {
1807              c = *eptr;
1808              if (c == '_') cur_is_word = TRUE; else
1809                {
1810                int cat = UCD_CATEGORY(c);
1811                cur_is_word = (cat == ucp_L || cat == ucp_N);
1812                }
1813              }
1814            else
1815    #endif
1816            cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);
1817          }          }
1818    
1819        /* Now see if the situation is what we want */        /* Now see if the situation is what we want */
1820    
1821        if ((*ecode++ == OP_WORD_BOUNDARY)?        if ((*ecode++ == OP_WORD_BOUNDARY)?
1822             cur_is_word == prev_is_word : cur_is_word != prev_is_word)             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
1823          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1824        }        }
1825      break;      break;
1826    
1827      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1828    
1829      case OP_ANY:      case OP_ANY:
1830      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
1831      /* Fall through */      /* Fall through */
1832    
1833      case OP_ALLANY:      case OP_ALLANY:
1834      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr++ >= md->end_subject)
1835          {
1836          SCHECK_PARTIAL();
1837          MRRETURN(MATCH_NOMATCH);
1838          }
1839      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1840      ecode++;      ecode++;
1841      break;      break;
# Line 1529  for (;;) Line 1844  for (;;)
1844      any byte, even newline, independent of the setting of PCRE_DOTALL. */      any byte, even newline, independent of the setting of PCRE_DOTALL. */
1845    
1846      case OP_ANYBYTE:      case OP_ANYBYTE:
1847      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr++ >= md->end_subject)
1848          {
1849          SCHECK_PARTIAL();
1850          MRRETURN(MATCH_NOMATCH);
1851          }
1852      ecode++;      ecode++;
1853      break;      break;
1854    
1855      case OP_NOT_DIGIT:      case OP_NOT_DIGIT:
1856      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1857          {
1858          SCHECK_PARTIAL();
1859          MRRETURN(MATCH_NOMATCH);
1860          }
1861      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1862      if (      if (
1863  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1542  for (;;) Line 1865  for (;;)
1865  #endif  #endif
1866         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
1867         )         )
1868        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1869      ecode++;      ecode++;
1870      break;      break;
1871    
1872      case OP_DIGIT:      case OP_DIGIT:
1873      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1874          {
1875          SCHECK_PARTIAL();
1876          MRRETURN(MATCH_NOMATCH);
1877          }
1878      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1879      if (      if (
1880  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1555  for (;;) Line 1882  for (;;)
1882  #endif  #endif
1883         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
1884         )         )
1885        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1886      ecode++;      ecode++;
1887      break;      break;
1888    
1889      case OP_NOT_WHITESPACE:      case OP_NOT_WHITESPACE:
1890      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1891          {
1892          SCHECK_PARTIAL();
1893          MRRETURN(MATCH_NOMATCH);
1894          }
1895      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1896      if (      if (
1897  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1568  for (;;) Line 1899  for (;;)
1899  #endif  #endif
1900         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
1901         )         )
1902        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1903      ecode++;      ecode++;
1904      break;      break;
1905    
1906      case OP_WHITESPACE:      case OP_WHITESPACE:
1907      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1908          {
1909          SCHECK_PARTIAL();
1910          MRRETURN(MATCH_NOMATCH);
1911          }
1912      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1913      if (      if (
1914  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1581  for (;;) Line 1916  for (;;)
1916  #endif  #endif
1917         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
1918         )         )
1919        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1920      ecode++;      ecode++;
1921      break;      break;
1922    
1923      case OP_NOT_WORDCHAR:      case OP_NOT_WORDCHAR:
1924      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1925          {
1926          SCHECK_PARTIAL();
1927          MRRETURN(MATCH_NOMATCH);
1928          }
1929      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1930      if (      if (
1931  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1594  for (;;) Line 1933  for (;;)
1933  #endif  #endif
1934         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
1935         )         )
1936        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1937      ecode++;      ecode++;
1938      break;      break;
1939    
1940      case OP_WORDCHAR:      case OP_WORDCHAR:
1941      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1942          {
1943          SCHECK_PARTIAL();
1944          MRRETURN(MATCH_NOMATCH);
1945          }
1946      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1947      if (      if (
1948  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 1607  for (;;) Line 1950  for (;;)
1950  #endif  #endif
1951         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
1952         )         )
1953        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1954      ecode++;      ecode++;
1955      break;      break;
1956    
1957      case OP_ANYNL:      case OP_ANYNL:
1958      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1959          {
1960          SCHECK_PARTIAL();
1961          MRRETURN(MATCH_NOMATCH);
1962          }
1963      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1964      switch(c)      switch(c)
1965        {        {
1966        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
1967        case 0x000d:        case 0x000d:
1968        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1969        break;        break;
# Line 1629  for (;;) Line 1976  for (;;)
1976        case 0x0085:        case 0x0085:
1977        case 0x2028:        case 0x2028:
1978        case 0x2029:        case 0x2029:
1979        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
1980        break;        break;
1981        }        }
1982      ecode++;      ecode++;
1983      break;      break;
1984    
1985      case OP_NOT_HSPACE:      case OP_NOT_HSPACE:
1986      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
1987          {
1988          SCHECK_PARTIAL();
1989          MRRETURN(MATCH_NOMATCH);
1990          }
1991      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1992      switch(c)      switch(c)
1993        {        {
# Line 1660  for (;;) Line 2011  for (;;)
2011        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2012        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2013        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2014        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2015        }        }
2016      ecode++;      ecode++;
2017      break;      break;
2018    
2019      case OP_HSPACE:      case OP_HSPACE:
2020      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
2021          {
2022          SCHECK_PARTIAL();
2023          MRRETURN(MATCH_NOMATCH);
2024          }
2025      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2026      switch(c)      switch(c)
2027        {        {
2028        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2029        case 0x09:      /* HT */        case 0x09:      /* HT */
2030        case 0x20:      /* SPACE */        case 0x20:      /* SPACE */
2031        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
# Line 1696  for (;;) Line 2051  for (;;)
2051      break;      break;
2052    
2053      case OP_NOT_VSPACE:      case OP_NOT_VSPACE:
2054      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
2055          {
2056          SCHECK_PARTIAL();
2057          MRRETURN(MATCH_NOMATCH);
2058          }
2059      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2060      switch(c)      switch(c)
2061        {        {
# Line 1708  for (;;) Line 2067  for (;;)
2067        case 0x85:      /* NEL */        case 0x85:      /* NEL */
2068        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2069        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2070        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2071        }        }
2072      ecode++;      ecode++;
2073      break;      break;
2074    
2075      case OP_VSPACE:      case OP_VSPACE:
2076      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
2077          {
2078          SCHECK_PARTIAL();
2079          MRRETURN(MATCH_NOMATCH);
2080          }
2081      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2082      switch(c)      switch(c)
2083        {        {
2084        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2085        case 0x0a:      /* LF */        case 0x0a:      /* LF */
2086        case 0x0b:      /* VT */        case 0x0b:      /* VT */
2087        case 0x0c:      /* FF */        case 0x0c:      /* FF */
# Line 1737  for (;;) Line 2100  for (;;)
2100    
2101      case OP_PROP:      case OP_PROP:
2102      case OP_NOTPROP:      case OP_NOTPROP:
2103      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
2104          {
2105          SCHECK_PARTIAL();
2106          MRRETURN(MATCH_NOMATCH);
2107          }
2108      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2109        {        {
2110        const ucd_record *prop = GET_UCD(c);        const ucd_record *prop = GET_UCD(c);
# Line 1745  for (;;) Line 2112  for (;;)
2112        switch(ecode[1])        switch(ecode[1])
2113          {          {
2114          case PT_ANY:          case PT_ANY:
2115          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);          if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2116          break;          break;
2117    
2118          case PT_LAMP:          case PT_LAMP:
2119          if ((prop->chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
2120               prop->chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
2121               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2122            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2123           break;          break;
2124    
2125          case PT_GC:          case PT_GC:
2126          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2127            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2128          break;          break;
2129    
2130          case PT_PC:          case PT_PC:
2131          if ((ecode[2] != prop->chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2132            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2133          break;          break;
2134    
2135          case PT_SC:          case PT_SC:
2136          if ((ecode[2] != prop->script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
2137            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2138            break;
2139    
2140            /* These are specials */
2141    
2142            case PT_ALNUM:
2143            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2144                 _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2145              MRRETURN(MATCH_NOMATCH);
2146            break;
2147    
2148            case PT_SPACE:    /* Perl space */
2149            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2150                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2151                   == (op == OP_NOTPROP))
2152              MRRETURN(MATCH_NOMATCH);
2153          break;          break;
2154    
2155            case PT_PXSPACE:  /* POSIX space */
2156            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2157                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2158                 c == CHAR_FF || c == CHAR_CR)
2159                   == (op == OP_NOTPROP))
2160              MRRETURN(MATCH_NOMATCH);
2161            break;
2162    
2163            case PT_WORD:
2164            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2165                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2166                 c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2167              MRRETURN(MATCH_NOMATCH);
2168            break;
2169    
2170            /* This should never occur */
2171    
2172          default:          default:
2173          RRETURN(PCRE_ERROR_INTERNAL);          RRETURN(PCRE_ERROR_INTERNAL);
2174          }          }
# Line 1782  for (;;) Line 2181  for (;;)
2181      is in the binary; otherwise a compile-time error occurs. */      is in the binary; otherwise a compile-time error occurs. */
2182    
2183      case OP_EXTUNI:      case OP_EXTUNI:
2184      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
2185          {
2186          SCHECK_PARTIAL();
2187          MRRETURN(MATCH_NOMATCH);
2188          }
2189      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2190        {        {
2191        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
2192        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
2193        while (eptr < md->end_subject)        while (eptr < md->end_subject)
2194          {          {
2195          int len = 1;          int len = 1;
# Line 1831  for (;;) Line 2234  for (;;)
2234        referenced subpattern. */        referenced subpattern. */
2235    
2236        if (offset >= offset_top || md->offset_vector[offset] < 0)        if (offset >= offset_top || md->offset_vector[offset] < 0)
2237          length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1;          length = (md->jscript_compat)? 0 : (int)(md->end_subject - eptr + 1);
2238        else        else
2239          length = md->offset_vector[offset+1] - md->offset_vector[offset];          length = md->offset_vector[offset+1] - md->offset_vector[offset];
2240    
# Line 1862  for (;;) Line 2265  for (;;)
2265          break;          break;
2266    
2267          default:               /* No repeat follows */          default:               /* No repeat follows */
2268          if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);          if (!match_ref(offset, eptr, length, md, ims))
2269              {
2270              CHECK_PARTIAL();
2271              MRRETURN(MATCH_NOMATCH);
2272              }
2273          eptr += length;          eptr += length;
2274          continue;              /* With the main loop */          continue;              /* With the main loop */
2275          }          }
# Line 1881  for (;;) Line 2288  for (;;)
2288          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2289            {            {
2290            CHECK_PARTIAL();            CHECK_PARTIAL();
2291            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2292            }            }
2293          eptr += length;          eptr += length;
2294          }          }
# Line 1899  for (;;) Line 2306  for (;;)
2306            {            {
2307            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2308            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2309            if (fi >= max || !match_ref(offset, eptr, length, md, ims))            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2310              if (!match_ref(offset, eptr, length, md, ims))
2311              {              {
2312              CHECK_PARTIAL();              CHECK_PARTIAL();
2313              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2314              }              }
2315            eptr += length;            eptr += length;
2316            }            }
# Line 1916  for (;;) Line 2324  for (;;)
2324          pp = eptr;          pp = eptr;
2325          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2326            {            {
2327            if (!match_ref(offset, eptr, length, md, ims)) break;            if (!match_ref(offset, eptr, length, md, ims))
2328                {
2329                CHECK_PARTIAL();
2330                break;
2331                }
2332            eptr += length;            eptr += length;
2333            }            }
         CHECK_PARTIAL();  
2334          while (eptr >= pp)          while (eptr >= pp)
2335            {            {
2336            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15);
2337            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2338            eptr -= length;            eptr -= length;
2339            }            }
2340          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2341          }          }
2342        }        }
2343      /* Control never gets here */      /* Control never gets here */
2344    
   
   
2345      /* Match a bit-mapped character class, possibly repeatedly. This op code is      /* Match a bit-mapped character class, possibly repeatedly. This op code is
2346      used when all the characters in the class have values in the range 0-255,      used when all the characters in the class have values in the range 0-255,
2347      and either the matching is caseful, or the characters are in the range      and either the matching is caseful, or the characters are in the range
# Line 1989  for (;;) Line 2398  for (;;)
2398            {            {
2399            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2400              {              {
2401              CHECK_PARTIAL();              SCHECK_PARTIAL();
2402              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2403              }              }
2404            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2405            if (c > 255)            if (c > 255)
2406              {              {
2407              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2408              }              }
2409            else            else
2410              {              {
2411              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2412              }              }
2413            }            }
2414          }          }
# Line 2011  for (;;) Line 2420  for (;;)
2420            {            {
2421            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2422              {              {
2423              CHECK_PARTIAL();              SCHECK_PARTIAL();
2424              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2425              }              }
2426            c = *eptr++;            c = *eptr++;
2427            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2428            }            }
2429          }          }
2430    
# Line 2037  for (;;) Line 2446  for (;;)
2446              {              {
2447              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2448              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2449              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
2450              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2451                {                {
2452                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2453                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2454                }                }
2455              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2456              if (c > 255)              if (c > 255)
2457                {                {
2458                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2459                }                }
2460              else              else
2461                {                {
2462                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2463                }                }
2464              }              }
2465            }            }
# Line 2066  for (;;) Line 2471  for (;;)
2471              {              {
2472              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2473              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2474              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
2475              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2476                {                {
2477                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2478                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2479                }                }
2480              c = *eptr++;              c = *eptr++;
2481              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2482              }              }
2483            }            }
2484          /* Control never gets here */          /* Control never gets here */
# Line 2096  for (;;) Line 2497  for (;;)
2497            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2498              {              {
2499              int len = 1;              int len = 1;
2500              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
2501                  {
2502                  SCHECK_PARTIAL();
2503                  break;
2504                  }
2505              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
2506              if (c > 255)              if (c > 255)
2507                {                {
# Line 2108  for (;;) Line 2513  for (;;)
2513                }                }
2514              eptr += len;              eptr += len;
2515              }              }
           CHECK_PARTIAL();  
2516            for (;;)            for (;;)
2517              {              {
2518              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18);
# Line 2123  for (;;) Line 2527  for (;;)
2527            {            {
2528            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2529              {              {
2530              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
2531                  {
2532                  SCHECK_PARTIAL();
2533                  break;
2534                  }
2535              c = *eptr;              c = *eptr;
2536              if ((data[c/8] & (1 << (c&7))) == 0) break;              if ((data[c/8] & (1 << (c&7))) == 0) break;
2537              eptr++;              eptr++;
2538              }              }
           CHECK_PARTIAL();  
2539            while (eptr >= pp)            while (eptr >= pp)
2540              {              {
2541              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19);
# Line 2137  for (;;) Line 2544  for (;;)
2544              }              }
2545            }            }
2546    
2547          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2548          }          }
2549        }        }
2550      /* Control never gets here */      /* Control never gets here */
# Line 2189  for (;;) Line 2596  for (;;)
2596          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2597            {            {
2598            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2599            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2600            }            }
2601          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2602          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2603          }          }
2604    
2605        /* 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 2209  for (;;) Line 2616  for (;;)
2616            {            {
2617            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2618            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2619            if (fi >= max)            if (fi >= max) MRRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
2620            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2621              {              {
2622              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2623              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2624              }              }
2625            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2626            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2627            }            }
2628          /* Control never gets here */          /* Control never gets here */
2629          }          }
# Line 2233  for (;;) Line 2636  for (;;)
2636          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2637            {            {
2638            int len = 1;            int len = 1;
2639            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject)
2640                {
2641                SCHECK_PARTIAL();
2642                break;
2643                }
2644            GETCHARLENTEST(c, eptr, len);            GETCHARLENTEST(c, eptr, len);
2645            if (!_pcre_xclass(c, data)) break;            if (!_pcre_xclass(c, data)) break;
2646            eptr += len;            eptr += len;
2647            }            }
         CHECK_PARTIAL();  
2648          for(;;)          for(;;)
2649            {            {
2650            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
# Line 2246  for (;;) Line 2652  for (;;)
2652            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2653            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2654            }            }
2655          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2656          }          }
2657    
2658        /* Control never gets here */        /* Control never gets here */
# Line 2262  for (;;) Line 2668  for (;;)
2668        length = 1;        length = 1;
2669        ecode++;        ecode++;
2670        GETCHARLEN(fc, ecode, length);        GETCHARLEN(fc, ecode, length);
2671        if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);        if (length > md->end_subject - eptr)
2672        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);          {
2673            CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2674            MRRETURN(MATCH_NOMATCH);
2675            }
2676          while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2677        }        }
2678      else      else
2679  #endif  #endif
2680    
2681      /* Non-UTF-8 mode */      /* Non-UTF-8 mode */
2682        {        {
2683        if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);        if (md->end_subject - eptr < 1)
2684        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);          {
2685            SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2686            MRRETURN(MATCH_NOMATCH);
2687            }
2688          if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2689        ecode += 2;        ecode += 2;
2690        }        }
2691      break;      break;
# Line 2286  for (;;) Line 2700  for (;;)
2700        ecode++;        ecode++;
2701        GETCHARLEN(fc, ecode, length);        GETCHARLEN(fc, ecode, length);
2702    
2703        if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);        if (length > md->end_subject - eptr)
2704            {
2705            CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2706            MRRETURN(MATCH_NOMATCH);
2707            }
2708    
2709        /* 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
2710        can use the fast lookup table. */        can use the fast lookup table. */
2711    
2712        if (fc < 128)        if (fc < 128)
2713          {          {
2714          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2715          }          }
2716    
2717        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 2312  for (;;) Line 2730  for (;;)
2730  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2731            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
2732  #endif  #endif
2733              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2734            }            }
2735          }          }
2736        }        }
# Line 2321  for (;;) Line 2739  for (;;)
2739    
2740      /* Non-UTF-8 mode */      /* Non-UTF-8 mode */
2741        {        {
2742        if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);        if (md->end_subject - eptr < 1)
2743        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          {
2744            SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2745            MRRETURN(MATCH_NOMATCH);
2746            }
2747          if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2748        ecode += 2;        ecode += 2;
2749        }        }
2750      break;      break;
# Line 2375  for (;;) Line 2797  for (;;)
2797      case OP_MINQUERY:      case OP_MINQUERY:
2798      c = *ecode++ - OP_STAR;      c = *ecode++ - OP_STAR;
2799      minimize = (c & 1) != 0;      minimize = (c & 1) != 0;
2800    
2801      min = rep_min[c];                 /* Pick up values from tables; */      min = rep_min[c];                 /* Pick up values from tables; */
2802      max = rep_max[c];                 /* zero for max => infinity */      max = rep_max[c];                 /* zero for max => infinity */
2803      if (max == 0) max = INT_MAX;      if (max == 0) max = INT_MAX;
# Line 2415  for (;;) Line 2838  for (;;)
2838            else            else
2839              {              {
2840              CHECK_PARTIAL();              CHECK_PARTIAL();
2841              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2842              }              }
2843            }            }
2844    
# Line 2427  for (;;) Line 2850  for (;;)
2850              {              {
2851              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2852              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2853              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
2854              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2855                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2856  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2442  for (;;) Line 2861  for (;;)
2861              else              else
2862                {                {
2863                CHECK_PARTIAL();                CHECK_PARTIAL();
2864                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2865                }                }
2866              }              }
2867            /* Control never gets here */            /* Control never gets here */
# Line 2460  for (;;) Line 2879  for (;;)
2879                       eptr <= md->end_subject - oclength &&                       eptr <= md->end_subject - oclength &&
2880                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
2881  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2882              else break;              else
2883              }                {
2884                  CHECK_PARTIAL();
2885            CHECK_PARTIAL();                break;
2886            if (possessive) continue;                }
2887                }
2888    
2889              if (possessive) continue;
2890    
2891            for(;;)            for(;;)
2892              {              {
2893              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2894              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2895              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
2896  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2897              eptr--;              eptr--;
2898              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2513  for (;;) Line 2935  for (;;)
2935          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2936            {            {
2937            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2938            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2939            }            }
2940          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2941          }          }
2942        if (min == max) continue;        if (min == max) continue;
2943        if (minimize)        if (minimize)
# Line 2524  for (;;) Line 2946  for (;;)
2946            {            {
2947            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2948            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2949            if (fi >= max)            if (fi >= max) MRRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
2950            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2951              {              {
2952              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2953              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2954              }              }
2955            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2956            }            }
2957          /* Control never gets here */          /* Control never gets here */
2958          }          }
# Line 2543  for (;;) Line 2961  for (;;)
2961          pp = eptr;          pp = eptr;
2962          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2963            {            {
2964            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;            if (eptr >= md->end_subject)
2965                {
2966                SCHECK_PARTIAL();
2967                break;
2968                }
2969              if (fc != md->lcc[*eptr]) break;
2970            eptr++;            eptr++;
2971            }            }
2972    
         CHECK_PARTIAL();  
2973          if (possessive) continue;          if (possessive) continue;
2974    
2975          while (eptr >= pp)          while (eptr >= pp)
# Line 2556  for (;;) Line 2978  for (;;)
2978            eptr--;            eptr--;
2979            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2980            }            }
2981          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2982          }          }
2983        /* Control never gets here */        /* Control never gets here */
2984        }        }
# Line 2570  for (;;) Line 2992  for (;;)
2992          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2993            {            {
2994            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2995            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2996            }            }
2997          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
2998          }          }
2999    
3000        if (min == max) continue;        if (min == max) continue;
3001    
3002        if (minimize)        if (minimize)
3003          {          {
3004          for (fi = min;; fi++)          for (fi = min;; fi++)
3005            {            {
3006            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
3007            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3008            if (fi >= max)            if (fi >= max) MRRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
3009            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3010              {              {
3011              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3012              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3013              }              }
3014            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
3015            }            }
3016          /* Control never gets here */          /* Control never gets here */
3017          }          }
# Line 2600  for (;;) Line 3020  for (;;)
3020          pp = eptr;          pp = eptr;
3021          for (i = min; i < max; i++)          for (i = min; i < max; i++)
3022            {            {
3023            if (eptr >= md->end_subject || fc != *eptr) break;            if (eptr >= md->end_subject)
3024                {
3025                SCHECK_PARTIAL();
3026                break;
3027                }
3028              if (fc != *eptr) break;
3029            eptr++;            eptr++;
3030            }            }
         CHECK_PARTIAL();  
3031          if (possessive) continue;          if (possessive) continue;
3032    
3033          while (eptr >= pp)          while (eptr >= pp)
3034            {            {
3035            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27);
3036            eptr--;            eptr--;
3037            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3038            }            }
3039          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3040          }          }
3041        }        }
3042      /* Control never gets here */      /* Control never gets here */
# Line 2620  for (;;) Line 3045  for (;;)
3045      checking can be multibyte. */      checking can be multibyte. */
3046    
3047      case OP_NOT:      case OP_NOT:
3048      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject)
3049          {
3050          SCHECK_PARTIAL();
3051          MRRETURN(MATCH_NOMATCH);
3052          }
3053      ecode++;      ecode++;
3054      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
3055      if ((ims & PCRE_CASELESS) != 0)      if ((ims & PCRE_CASELESS) != 0)
# Line 2629  for (;;) Line 3058  for (;;)
3058        if (c < 256)        if (c < 256)
3059  #endif  #endif
3060        c = md->lcc[c];        c = md->lcc[c];
3061        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
3062        }        }
3063      else      else
3064        {        {
3065        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
3066        }        }
3067      break;      break;
3068    
# Line 2727  for (;;) Line 3156  for (;;)
3156            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3157              {              {
3158              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3159              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3160              }              }
3161            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3162            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3163            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3164            }            }
3165          }          }
3166        else        else
# Line 2744  for (;;) Line 3173  for (;;)
3173            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3174              {              {
3175              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3176              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3177              }              }
3178            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3179            }            }
3180          }          }
3181    
# Line 2763  for (;;) Line 3192  for (;;)
3192              {              {
3193              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3194              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3195              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3196              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3197                {                {
3198                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3199                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3200                }                }
3201              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3202              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3203              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3204              }              }
3205            }            }
3206          else          else
# Line 2786  for (;;) Line 3211  for (;;)
3211              {              {
3212              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3213              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3214              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3215              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3216                {                {
3217                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3218                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3219                }                }
3220              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3221              }              }
3222            }            }
3223          /* Control never gets here */          /* Control never gets here */
# Line 2816  for (;;) Line 3237  for (;;)
3237            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3238              {              {
3239              int len = 1;              int len = 1;
3240              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
3241                  {
3242                  SCHECK_PARTIAL();
3243                  break;
3244                  }
3245              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3246              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3247              if (fc == d) break;              if (fc == d) break;
3248              eptr += len;              eptr += len;
3249              }              }
         CHECK_PARTIAL();  
3250          if (possessive) continue;          if (possessive) continue;
3251          for(;;)          for(;;)
3252              {              {
# Line 2838  for (;;) Line 3262  for (;;)
3262            {            {
3263            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3264              {              {
3265              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;              if (eptr >= md->end_subject)
3266                  {
3267                  SCHECK_PARTIAL();
3268                  break;
3269                  }
3270                if (fc == md->lcc[*eptr]) break;
3271              eptr++;              eptr++;
3272              }              }
           CHECK_PARTIAL();  
3273            if (possessive) continue;            if (possessive) continue;
3274            while (eptr >= pp)            while (eptr >= pp)
3275              {              {
# Line 2851  for (;;) Line 3279  for (;;)
3279              }              }
3280            }            }
3281    
3282          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3283          }          }
3284        /* Control never gets here */        /* Control never gets here */
3285        }        }
# Line 2870  for (;;) Line 3298  for (;;)
3298            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3299              {              {
3300              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3301              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3302              }              }
3303            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3304            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3305            }            }
3306          }          }
3307        else        else
# Line 2885  for (;;) Line 3313  for (;;)
3313            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3314              {              {
3315              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3316              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3317              }              }
3318            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3319            }            }
3320          }          }
3321    
# Line 2904  for (;;) Line 3332  for (;;)
3332              {              {
3333              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3334              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3335              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3336              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3337                {                {
3338                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3339                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3340                }                }
3341              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3342              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3343              }              }
3344            }            }
3345          else          else
# Line 2926  for (;;) Line 3350  for (;;)
3350              {              {
3351              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3352              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3353              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
3354              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3355                {                {
3356                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3357                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3358                }                }
3359              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3360              }              }
3361            }            }
3362          /* Control never gets here */          /* Control never gets here */
# Line 2956  for (;;) Line 3376  for (;;)
3376            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3377              {              {
3378              int len = 1;              int len = 1;
3379              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
3380                  {
3381                  SCHECK_PARTIAL();
3382                  break;
3383                  }
3384              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3385              if (fc == d) break;              if (fc == d) break;
3386              eptr += len;              eptr += len;
3387              }              }
           CHECK_PARTIAL();  
3388            if (possessive) continue;            if (possessive) continue;
3389            for(;;)            for(;;)
3390              {              {
# Line 2977  for (;;) Line 3400  for (;;)
3400            {            {
3401            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3402              {              {
3403              if (eptr >= md->end_subject || fc == *eptr) break;              if (eptr >= md->end_subject)
3404                  {
3405                  SCHECK_PARTIAL();
3406                  break;
3407                  }
3408                if (fc == *eptr) break;
3409              eptr++;              eptr++;
3410              }              }
           CHECK_PARTIAL();  
3411            if (possessive) continue;            if (possessive) continue;
3412            while (eptr >= pp)            while (eptr >= pp)
3413              {              {
# Line 2990  for (;;) Line 3417  for (;;)
3417              }              }
3418            }            }
3419    
3420          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3421          }          }
3422        }        }
3423      /* Control never gets here */      /* Control never gets here */
# Line 3084  for (;;) Line 3511  for (;;)
3511          switch(prop_type)          switch(prop_type)
3512            {            {
3513            case PT_ANY:            case PT_ANY:
3514            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3515            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3516              {              {
3517              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3518                {                {
3519                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3520                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3521                }                }
3522              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3523              }              }
# Line 3102  for (;;) Line 3529  for (;;)
3529              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3530                {                {
3531                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3532                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3533                }                }
3534              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3535              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3536              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3537                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3538                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
3539                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3540              }              }
3541            break;            break;
3542    
# Line 3119  for (;;) Line 3546  for (;;)
3546              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3547                {                {
3548                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3549                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3550                }                }
3551              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3552              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3553              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3554                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3555              }              }
3556            break;            break;
3557    
# Line 3134  for (;;) Line 3561  for (;;)
3561              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3562                {                {
3563                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3564                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3565                }                }
3566              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3567              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3568              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3569                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3570              }              }
3571            break;            break;
3572    
# Line 3149  for (;;) Line 3576  for (;;)
3576              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3577                {                {
3578                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3579                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3580                }                }
3581              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3582              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3583              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3584                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3585                }
3586              break;
3587    
3588              case PT_ALNUM:
3589              for (i = 1; i <= min; i++)
3590                {
3591                if (eptr >= md->end_subject)
3592                  {
3593                  SCHECK_PARTIAL();
3594                  MRRETURN(MATCH_NOMATCH);
3595                  }
3596                GETCHARINCTEST(c, eptr);
3597                prop_category = UCD_CATEGORY(c);
3598                if ((prop_category == ucp_L || prop_category == ucp_N)
3599                       == prop_fail_result)
3600                  MRRETURN(MATCH_NOMATCH);
3601                }
3602              break;
3603    
3604              case PT_SPACE:    /* Perl space */
3605              for (i = 1; i <= min; i++)
3606                {
3607                if (eptr >= md->end_subject)
3608                  {
3609                  SCHECK_PARTIAL();
3610                  MRRETURN(MATCH_NOMATCH);
3611                  }
3612                GETCHARINCTEST(c, eptr);
3613                prop_category = UCD_CATEGORY(c);
3614                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3615                     c == CHAR_FF || c == CHAR_CR)
3616                       == prop_fail_result)
3617                  MRRETURN(MATCH_NOMATCH);
3618                }
3619              break;
3620    
3621              case PT_PXSPACE:  /* POSIX space */
3622              for (i = 1; i <= min; i++)
3623                {
3624                if (eptr >= md->end_subject)
3625                  {
3626                  SCHECK_PARTIAL();
3627                  MRRETURN(MATCH_NOMATCH);
3628                  }
3629                GETCHARINCTEST(c, eptr);
3630                prop_category = UCD_CATEGORY(c);
3631                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3632                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
3633                       == prop_fail_result)
3634                  MRRETURN(MATCH_NOMATCH);
3635                }
3636              break;
3637    
3638              case PT_WORD:
3639              for (i = 1; i <= min; i++)
3640                {
3641                if (eptr >= md->end_subject)
3642                  {
3643                  SCHECK_PARTIAL();
3644                  MRRETURN(MATCH_NOMATCH);
3645                  }
3646                GETCHARINCTEST(c, eptr);
3647                prop_category = UCD_CATEGORY(c);
3648                if ((prop_category == ucp_L || prop_category == ucp_N ||
3649                     c == CHAR_UNDERSCORE)
3650                       == prop_fail_result)
3651                  MRRETURN(MATCH_NOMATCH);
3652              }              }
3653            break;            break;
3654    
3655              /* This should not occur */
3656    
3657            default:            default:
3658            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
3659            }            }
# Line 3173  for (;;) Line 3669  for (;;)
3669            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3670              {              {
3671              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3672              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3673              }              }
3674            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3675            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3676            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
3677            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3678              {              {
3679              int len = 1;              int len = 1;
# Line 3204  for (;;) Line 3700  for (;;)
3700            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3701              {              {
3702              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3703              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3704              }              }
3705            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3706            eptr++;            eptr++;
3707            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3708            }            }
# Line 3218  for (;;) Line 3714  for (;;)
3714            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3715              {              {
3716              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3717              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3718              }              }
3719            eptr++;            eptr++;
3720            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3226  for (;;) Line 3722  for (;;)
3722          break;          break;
3723    
3724          case OP_ANYBYTE:          case OP_ANYBYTE:
3725          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
3726          eptr += min;          eptr += min;
3727          break;          break;
3728    
# Line 3236  for (;;) Line 3732  for (;;)
3732            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3733              {              {
3734              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3735              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3736              }              }
3737            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3738            switch(c)            switch(c)
3739              {              {
3740              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3741              case 0x000d:              case 0x000d:
3742              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3743              break;              break;
# Line 3254  for (;;) Line 3750  for (;;)
3750              case 0x0085:              case 0x0085:
3751              case 0x2028:              case 0x2028:
3752              case 0x2029:              case 0x2029:
3753              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3754              break;              break;
3755              }              }
3756            }            }
# Line 3266  for (;;) Line 3762  for (;;)
3762            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3763              {              {
3764              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3765              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3766              }              }
3767            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3768            switch(c)            switch(c)
# Line 3291  for (;;) Line 3787  for (;;)
3787              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
3788              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3789              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
3790              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3791              }              }
3792            }            }
3793          break;          break;
# Line 3302  for (;;) Line 3798  for (;;)
3798            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3799              {              {
3800              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3801              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3802              }              }
3803            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3804            switch(c)            switch(c)
3805              {              {
3806              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3807              case 0x09:      /* HT */              case 0x09:      /* HT */
3808              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3809              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3338  for (;;) Line 3834  for (;;)
3834            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3835              {              {
3836              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3837              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3838              }              }
3839            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3840            switch(c)            switch(c)
# Line 3351  for (;;) Line 3847  for (;;)
3847              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3848              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
3849              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
3850              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3851              }              }
3852            }            }
3853          break;          break;
# Line 3362  for (;;) Line 3858  for (;;)
3858            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3859              {              {
3860              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3861              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3862              }              }
3863            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3864            switch(c)            switch(c)
3865              {              {
3866              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3867              case 0x0a:      /* LF */              case 0x0a:      /* LF */
3868              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3869              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3386  for (;;) Line 3882  for (;;)
3882            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3883              {              {
3884              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3885              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3886              }              }
3887            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3888            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3889              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3890            }            }
3891          break;          break;
3892    
# Line 3400  for (;;) Line 3896  for (;;)
3896            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3897              {              {
3898              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3899              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3900              }              }
3901            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3902              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3903            /* 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 */
3904            }            }
3905          break;          break;
# Line 3414  for (;;) Line 3910  for (;;)
3910            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3911              {              {
3912              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3913              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3914              }              }
3915            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3916              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3917            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3918            }            }
3919          break;          break;
# Line 3428  for (;;) Line 3924  for (;;)
3924            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3925              {              {
3926              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3927              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3928              }              }
3929            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3930              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3931            /* 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 */
3932            }            }
3933          break;          break;
# Line 3439  for (;;) Line 3935  for (;;)
3935          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3936          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3937            {            {
3938            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject)
3939               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))              {
3940              RRETURN(MATCH_NOMATCH);              SCHECK_PARTIAL();
3941                MRRETURN(MATCH_NOMATCH);
3942                }
3943              if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3944                MRRETURN(MATCH_NOMATCH);
3945            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3946            }            }
3947          break;          break;
# Line 3452  for (;;) Line 3952  for (;;)
3952            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3953              {              {
3954              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3955              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3956              }              }
3957            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3958              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3959            /* 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 */
3960            }            }
3961          break;          break;
# Line 3478  for (;;) Line 3978  for (;;)
3978            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3979              {              {
3980              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3981              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3982              }              }
3983            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3984            eptr++;            eptr++;
3985            }            }
3986          break;          break;
3987    
3988          case OP_ALLANY:          case OP_ALLANY:
3989          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min)
3990              {
3991              SCHECK_PARTIAL();
3992              MRRETURN(MATCH_NOMATCH);
3993              }
3994          eptr += min;          eptr += min;
3995          break;          break;
3996    
3997          case OP_ANYBYTE:          case OP_ANYBYTE:
3998          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min)
3999              {
4000              SCHECK_PARTIAL();
4001              MRRETURN(MATCH_NOMATCH);
4002              }
4003          eptr += min;          eptr += min;
4004          break;          break;
4005    
# Line 3501  for (;;) Line 4009  for (;;)
4009            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4010              {              {
4011              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4012              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4013              }              }
4014            switch(*eptr++)            switch(*eptr++)
4015              {              {
4016              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4017              case 0x000d:              case 0x000d:
4018              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4019              break;              break;
# Line 3515  for (;;) Line 4023  for (;;)
4023              case 0x000b:              case 0x000b:
4024              case 0x000c:              case 0x000c:
4025              case 0x0085:              case 0x0085:
4026              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4027              break;              break;
4028              }              }
4029            }            }
# Line 3527  for (;;) Line 4035  for (;;)
4035            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4036              {              {
4037              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4038              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4039              }              }
4040            switch(*eptr++)            switch(*eptr++)
4041              {              {
# Line 3535  for (;;) Line 4043  for (;;)
4043              case 0x09:      /* HT */              case 0x09:      /* HT */
4044              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4045              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4046              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4047              }              }
4048            }            }
4049          break;          break;
# Line 3546  for (;;) Line 4054  for (;;)
4054            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4055              {              {
4056              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4057              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4058              }              }
4059            switch(*eptr++)            switch(*eptr++)
4060              {              {
4061              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4062              case 0x09:      /* HT */              case 0x09:      /* HT */
4063              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4064              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3565  for (;;) Line 4073  for (;;)
4073            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4074              {              {
4075              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4076              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4077              }              }
4078            switch(*eptr++)            switch(*eptr++)
4079              {              {
# Line 3575  for (;;) Line 4083  for (;;)
4083              case 0x0c:      /* FF */              case 0x0c:      /* FF */
4084              case 0x0d:      /* CR */              case 0x0d:      /* CR */
4085              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4086              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4087              }              }
4088            }            }
4089          break;          break;
# Line 3586  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              {              {
4101              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4102              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4103              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4104              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3607  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            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4121            }            }
4122          break;          break;
4123    
# Line 3619  for (;;) Line 4127  for (;;)
4127            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4128              {              {
4129              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4130              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4131              }              }
4132            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4133            }            }
4134          break;          break;
4135    
# Line 3631  for (;;) Line 4139  for (;;)
4139            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4140              {              {
4141              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4142              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4143              }              }
4144            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4145            }            }
4146          break;          break;
4147    
# Line 3643  for (;;) Line 4151  for (;;)
4151            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4152              {              {
4153              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4154              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4155              }              }
4156            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4157            }            }
4158          break;          break;
4159    
# Line 3655  for (;;) Line 4163  for (;;)
4163            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4164              {              {
4165              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4166              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4167              }              }
4168            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4169              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4170            }            }
4171          break;          break;
4172    
# Line 3668  for (;;) Line 4176  for (;;)
4176            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4177              {              {
4178              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4179              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4180              }              }
4181            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4182              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4183            }            }
4184          break;          break;
4185    
# Line 3700  for (;;) Line 4208  for (;;)
4208              {              {
4209              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
4210              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4211              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
4212              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4213                {                {
4214                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4215                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4216                }                }
4217              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4218              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
4219              }              }
4220            /* Control never gets here */            /* Control never gets here */
4221    
# Line 3720  for (;;) Line 4224  for (;;)
4224              {              {
4225              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
4226              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4227              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
4228              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4229                {                {
4230                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4231                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4232                }                }
4233              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4234              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4235              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4236                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
4237                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
4238                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4239              }              }
4240            /* Control never gets here */            /* Control never gets here */
4241    
# Line 3744  for (;;) Line 4244  for (;;)
4244              {              {
4245              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4246              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4247              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
4248              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4249                {                {
4250                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4251                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4252                }                }
4253              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4254              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4255              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4256                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4257              }              }
4258            /* Control never gets here */            /* Control never gets here */
4259    
# Line 3766  for (;;) Line 4262  for (;;)
4262              {              {
4263              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4264              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4265              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
4266              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4267                {                {
4268                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4269                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4270                }                }
4271              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4272              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4273              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4274                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4275              }              }
4276            /* Control never gets here */            /* Control never gets here */
4277    
# Line 3788  for (;;) Line 4280  for (;;)
4280              {              {
4281              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4282              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4283              if (fi >= max)              if (fi >= max) MRRETURN(MATCH_NOMATCH);
               {  
               CHECK_PARTIAL();  
               RRETURN(MATCH_NOMATCH);  
               }  
4284              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4285                {                {
4286                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4287                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4288                }                }
4289              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
4290              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4291              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4292                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4293                }
4294              /* Control never gets here */
4295    
4296              case PT_ALNUM:
4297              for (fi = min;; fi++)
4298                {
4299                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM59);
4300                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4301                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4302                if (eptr >= md->end_subject)
4303                  {
4304                  SCHECK_PARTIAL();
4305                  MRRETURN(MATCH_NOMATCH);
4306                  }
4307                GETCHARINCTEST(c, eptr);
4308                prop_category = UCD_CATEGORY(c);
4309                if ((prop_category == ucp_L || prop_category == ucp_N)
4310                       == prop_fail_result)
4311                  MRRETURN(MATCH_NOMATCH);
4312              }              }
4313            /* Control never gets here */            /* Control never gets here */
4314    
4315              case PT_SPACE:    /* Perl space */
4316              for (fi = min;; fi++)
4317                {
4318                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM60);
4319                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4320                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4321                if (eptr >= md->end_subject)
4322                  {
4323                  SCHECK_PARTIAL();
4324                  MRRETURN(MATCH_NOMATCH);
4325                  }
4326                GETCHARINCTEST(c, eptr);
4327                prop_category = UCD_CATEGORY(c);
4328                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4329                     c == CHAR_FF || c == CHAR_CR)
4330                       == prop_fail_result)
4331                  MRRETURN(MATCH_NOMATCH);
4332                }
4333              /* Control never gets here */
4334    
4335              case PT_PXSPACE:  /* POSIX space */
4336              for (fi = min;; fi++)
4337                {
4338                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM61);
4339                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4340                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4341                if (eptr >= md->end_subject)
4342                  {
4343                  SCHECK_PARTIAL();
4344                  MRRETURN(MATCH_NOMATCH);
4345                  }
4346                GETCHARINCTEST(c, eptr);
4347                prop_category = UCD_CATEGORY(c);
4348                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4349                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4350                       == prop_fail_result)
4351                  MRRETURN(MATCH_NOMATCH);
4352                }
4353              /* Control never gets here */
4354    
4355              case PT_WORD:
4356              for (fi = min;; fi++)
4357                {
4358                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM62);
4359                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4360                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4361                if (eptr >= md->end_subject)
4362                  {
4363                  SCHECK_PARTIAL();
4364                  MRRETURN(MATCH_NOMATCH);
4365                  }
4366                GETCHARINCTEST(c, eptr);
4367                prop_category = UCD_CATEGORY(c);
4368                if ((prop_category == ucp_L ||
4369                     prop_category == ucp_N ||
4370                     c == CHAR_UNDERSCORE)
4371                       == prop_fail_result)
4372                  MRRETURN(MATCH_NOMATCH);
4373                }
4374              /* Control never gets here */
4375    
4376              /* This should never occur */
4377    
4378            default:            default:
4379            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4380            }            }
# Line 3819  for (;;) Line 4389  for (;;)
4389            {            {
4390            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4391            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4392            if (fi >= max)            if (fi >= max) MRRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
4393            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4394              {              {
4395              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4396              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4397              }              }
4398            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4399            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4400            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
4401            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4402              {              {
4403              int len = 1;              int len = 1;
# Line 3855  for (;;) Line 4421  for (;;)
4421            {            {
4422            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4423            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4424            if (fi >= max)            if (fi >= max) MRRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
4425            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4426              {              {
4427              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4428              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4429              }              }
4430            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4431              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4432            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4433            switch(ctype)            switch(ctype)
4434              {              {
# Line 3878  for (;;) Line 4440  for (;;)
4440              case OP_ANYNL:              case OP_ANYNL:
4441              switch(c)              switch(c)
4442                {                {
4443                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4444                case 0x000d:                case 0x000d:
4445                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4446                break;                break;
# Line 3890  for (;;) Line 4452  for (;;)
4452                case 0x0085:                case 0x0085:
4453                case 0x2028:                case 0x2028:
4454                case 0x2029:                case 0x2029:
4455                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4456                break;                break;
4457                }                }
4458              break;              break;
# Line 3918  for (;;) Line 4480  for (;;)
4480                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4481                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4482                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4483                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4484                }                }
4485              break;              break;
4486    
4487              case OP_HSPACE:              case OP_HSPACE:
4488              switch(c)              switch(c)
4489                {                {
4490                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4491                case 0x09:      /* HT */                case 0x09:      /* HT */
4492                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4493                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 3960  for (;;) Line 4522  for (;;)
4522                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4523                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4524                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4525                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4526                }                }
4527              break;              break;
4528    
4529              case OP_VSPACE:              case OP_VSPACE:
4530              switch(c)              switch(c)
4531                {                {
4532                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4533                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4534                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4535                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 3981  for (;;) Line 4543  for (;;)
4543    
4544              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4545              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4546                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4547              break;              break;
4548    
4549              case OP_DIGIT:              case OP_DIGIT:
4550              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4551                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4552              break;              break;
4553    
4554              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4555              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4556                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4557              break;              break;
4558    
4559              case OP_WHITESPACE:              case OP_WHITESPACE:
4560              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4561                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4562              break;              break;
4563    
4564              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4565              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4566                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4567              break;              break;
4568    
4569              case OP_WORDCHAR:              case OP_WORDCHAR:
4570              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4571                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4572              break;              break;
4573    
4574              default:              default:
# Line 4022  for (;;) Line 4584  for (;;)
4584            {            {
4585            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4586            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4587            if (fi >= max)            if (fi >= max) MRRETURN(MATCH_NOMATCH);
             {  
             CHECK_PARTIAL();  
             RRETURN(MATCH_NOMATCH);  
             }  
4588            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4589              {              {
4590              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4591              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4592              }              }
4593            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4594              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4595            c = *eptr++;            c = *eptr++;
4596            switch(ctype)            switch(ctype)
4597              {              {
# Line 4045  for (;;) Line 4603  for (;;)
4603              case OP_ANYNL:              case OP_ANYNL:
4604              switch(c)              switch(c)
4605                {                {
4606                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4607                case 0x000d:                case 0x000d:
4608                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4609                break;                break;
# Line 4056  for (;;) Line 4614  for (;;)
4614                case 0x000b:                case 0x000b:
4615                case 0x000c:                case 0x000c:
4616                case 0x0085:                case 0x0085:
4617                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4618                break;                break;
4619                }                }
4620              break;              break;
# Line 4068  for (;;) Line 4626  for (;;)
4626                case 0x09:      /* HT */                case 0x09:      /* HT */
4627                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4628                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4629                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4630                }                }
4631              break;              break;
4632    
4633              case OP_HSPACE:              case OP_HSPACE:
4634              switch(c)              switch(c)
4635                {                {
4636                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4637                case 0x09:      /* HT */                case 0x09:      /* HT */
4638                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4639                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4092  for (;;) Line 4650  for (;;)
4650                case 0x0c:      /* FF */                case 0x0c:      /* FF */
4651                case 0x0d:      /* CR */                case 0x0d:      /* CR */
4652                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4653                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4654                }                }
4655              break;              break;
4656    
4657              case OP_VSPACE:              case OP_VSPACE:
4658              switch(c)              switch(c)
4659                {                {
4660                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4661                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4662                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4663                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4110  for (;;) Line 4668  for (;;)
4668              break;              break;
4669    
4670              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4671              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4672              break;              break;
4673    
4674              case OP_DIGIT:              case OP_DIGIT:
4675              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4676              break;              break;
4677    
4678              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4679              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4680              break;              break;
4681    
4682              case OP_WHITESPACE:              case OP_WHITESPACE:
4683              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4684              break;              break;
4685    
4686              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4687              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
4688              break;              break;
4689    
4690              case OP_WORDCHAR:              case OP_WORDCHAR:
4691              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
4692              break;              break;
4693    
4694              default:              default:
# Line 4158  for (;;) Line 4716  for (;;)
4716            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4717              {              {
4718              int len = 1;              int len = 1;
4719              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4720              GETCHARLEN(c, eptr, len);                {
4721                  SCHECK_PARTIAL();
4722                  break;
4723                  }
4724                GETCHARLENTEST(c, eptr, len);
4725              if (prop_fail_result) break;              if (prop_fail_result) break;
4726              eptr+= len;              eptr+= len;
4727              }              }
# Line 4169  for (;;) Line 4731  for (;;)
4731            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4732              {              {
4733              int len = 1;              int len = 1;
4734              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4735              GETCHARLEN(c, eptr, len);                {
4736                  SCHECK_PARTIAL();
4737                  break;
4738                  }
4739                GETCHARLENTEST(c, eptr, len);
4740              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4741              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4742                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
# Line 4184  for (;;) Line 4750  for (;;)
4750            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4751              {              {
4752              int len = 1;              int len = 1;
4753              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4754              GETCHARLEN(c, eptr, len);                {
4755                  SCHECK_PARTIAL();
4756                  break;
4757                  }
4758                GETCHARLENTEST(c, eptr, len);
4759              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4760              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4761                break;                break;
# Line 4197  for (;;) Line 4767  for (;;)
4767            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4768              {              {
4769              int len = 1;              int len = 1;
4770              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4771              GETCHARLEN(c, eptr, len);                {
4772                  SCHECK_PARTIAL();
4773                  break;
4774                  }
4775                GETCHARLENTEST(c, eptr, len);
4776              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4777              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4778                break;                break;
# Line 4210  for (;;) Line 4784  for (;;)
4784            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4785              {              {
4786              int len = 1;              int len = 1;
4787              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4788              GETCHARLEN(c, eptr, len);                {
4789                  SCHECK_PARTIAL();
4790                  break;
4791                  }
4792                GETCHARLENTEST(c, eptr, len);
4793              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4794              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4795                break;                break;
4796              eptr+= len;              eptr+= len;
4797              }              }
4798            break;            break;
4799    
4800              case PT_ALNUM:
4801              for (i = min; i < max; i++)
4802                {
4803                int len = 1;
4804                if (eptr >= md->end_subject)
4805                  {
4806                  SCHECK_PARTIAL();
4807                  break;
4808                  }
4809                GETCHARLENTEST(c, eptr, len);
4810                prop_category = UCD_CATEGORY(c);
4811                if ((prop_category == ucp_L || prop_category == ucp_N)
4812                     == prop_fail_result)
4813                  break;
4814                eptr+= len;
4815                }
4816              break;
4817    
4818              case PT_SPACE:    /* Perl space */
4819              for (i = min; i < max; i++)
4820                {
4821                int len = 1;
4822                if (eptr >= md->end_subject)
4823                  {
4824                  SCHECK_PARTIAL();
4825                  break;
4826                  }
4827                GETCHARLENTEST(c, eptr, len);
4828                prop_category = UCD_CATEGORY(c);
4829                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4830                     c == CHAR_FF || c == CHAR_CR)
4831                     == prop_fail_result)
4832                  break;
4833                eptr+= len;
4834                }
4835              break;
4836    
4837              case PT_PXSPACE:  /* POSIX space */
4838              for (i = min; i < max; i++)
4839                {
4840                int len = 1;
4841                if (eptr >= md->end_subject)
4842                  {
4843                  SCHECK_PARTIAL();
4844                  break;
4845                  }
4846                GETCHARLENTEST(c, eptr, len);
4847                prop_category = UCD_CATEGORY(c);
4848                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4849                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4850                     == prop_fail_result)
4851                  break;
4852                eptr+= len;
4853                }
4854              break;
4855    
4856              case PT_WORD:
4857              for (i = min; i < max; i++)
4858                {
4859                int len = 1;
4860                if (eptr >= md->end_subject)
4861                  {
4862                  SCHECK_PARTIAL();
4863                  break;
4864                  }
4865                GETCHARLENTEST(c, eptr, len);
4866                prop_category = UCD_CATEGORY(c);
4867                if ((prop_category == ucp_L || prop_category == ucp_N ||
4868                     c == CHAR_UNDERSCORE) == prop_fail_result)
4869                  break;
4870                eptr+= len;
4871                }
4872              break;
4873    
4874              default:
4875              RRETURN(PCRE_ERROR_INTERNAL);
4876            }            }
4877    
4878          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4879    
         CHECK_PARTIAL();  
4880          if (possessive) continue;          if (possessive) continue;
4881          for(;;)          for(;;)
4882            {            {
# Line 4240  for (;;) Line 4894  for (;;)
4894          {          {
4895          for (i = min; i < max; i++)          for (i = min; i < max; i++)
4896            {            {
4897            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject)
4898                {
4899                SCHECK_PARTIAL();
4900                break;
4901                }
4902            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4903            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4904            if (prop_category == ucp_M) break;            if (prop_category == ucp_M) break;
# Line 4259  for (;;) Line 4917  for (;;)
4917    
4918          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4919    
         CHECK_PARTIAL();  
4920          if (possessive) continue;          if (possessive) continue;
4921    
4922          for(;;)          for(;;)
4923            {            {
4924            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
# Line 4296  for (;;) Line 4954  for (;;)
4954              {              {
4955              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4956                {                {
4957                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                if (eptr >= md->end_subject)
4958                    {
4959                    SCHECK_PARTIAL();
4960                    break;
4961                    }
4962                  if (IS_NEWLINE(eptr)) break;
4963                eptr++;                eptr++;
4964                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4965                }                }
# Line 4308  for (;;) Line 4971  for (;;)
4971              {              {
4972              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4973                {                {
4974                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                if (eptr >= md->end_subject)
4975                    {
4976                    SCHECK_PARTIAL();
4977                    break;
4978                    }
4979                  if (IS_NEWLINE(eptr)) break;
4980                eptr++;                eptr++;
4981                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4982                }                }
# Line 4320  for (;;) Line 4988  for (;;)
4988              {              {
4989              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4990                {                {
4991                if (eptr >= md->end_subject) break;                if (eptr >= md->end_subject)
4992                    {
4993                    SCHECK_PARTIAL();
4994                    break;
4995                    }
4996                eptr++;                eptr++;
4997                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4998                }                }
# Line 4333  for (;;) Line 5005  for (;;)
5005            case OP_ANYBYTE:            case OP_ANYBYTE:
5006            c = max - min;            c = max - min;
5007            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
5008              c = md->end_subject - eptr;              {
5009            eptr += c;              eptr = md->end_subject;
5010                SCHECK_PARTIAL();
5011                }
5012              else eptr += c;
5013            break;            break;
5014    
5015            case OP_ANYNL:            case OP_ANYNL:
5016            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5017              {              {
5018              int len = 1;              int len = 1;
5019              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5020                  {
5021                  SCHECK_PARTIAL();
5022                  break;
5023                  }
5024              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5025              if (c == 0x000d)              if (c == 0x000d)
5026                {                {
# Line 4366  for (;;) Line 5045  for (;;)
5045              {              {
5046              BOOL gotspace;              BOOL gotspace;
5047              int len = 1;              int len = 1;
5048              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5049                  {
5050                  SCHECK_PARTIAL();
5051                  break;
5052                  }
5053              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5054              switch(c)              switch(c)
5055                {                {
# Line 4404  for (;;) Line 5087  for (;;)
5087              {              {
5088              BOOL gotspace;              BOOL gotspace;
5089              int len = 1;              int len = 1;
5090              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5091                  {
5092                  SCHECK_PARTIAL();
5093                  break;
5094                  }
5095              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5096              switch(c)              switch(c)
5097                {                {
# Line 4428  for (;;) Line 5115  for (;;)
5115            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5116              {              {
5117              int len = 1;              int len = 1;
5118              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5119                  {
5120                  SCHECK_PARTIAL();
5121                  break;
5122                  }
5123              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5124              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
5125              eptr+= len;              eptr+= len;
# Line 4439  for (;;) Line 5130  for (;;)
5130            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5131              {              {
5132              int len = 1;              int len = 1;
5133              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5134                  {
5135                  SCHECK_PARTIAL();
5136                  break;
5137                  }
5138              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5139              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;