/[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 455 by ph10, Sat Sep 26 19:12:32 2009 UTC revision 517 by ph10, Wed May 5 10:44:20 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 };
259    
260  /* 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
261  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
262  actuall used in this definition. */  actually used in this definition. */
263    
264  #ifndef NO_RECURSE  #ifndef NO_RECURSE
265  #define REGISTER register  #define REGISTER register
266    
267  #ifdef DEBUG  #ifdef PCRE_DEBUG
268  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
269    { \    { \
270    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
271    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); \
272    printf("to line %d\n", __LINE__); \    printf("to line %d\n", __LINE__); \
273    }    }
274  #define RRETURN(ra) \  #define RRETURN(ra) \
# Line 268  actuall used in this definition. */ Line 278  actuall used in this definition. */
278    }    }
279  #else  #else
280  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
281    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)
282  #define RRETURN(ra) return ra  #define RRETURN(ra) return ra
283  #endif  #endif
284    
# Line 288  argument of match(), which never changes Line 298  argument of match(), which never changes
298    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
299    newframe->Xecode = rb;\    newframe->Xecode = rb;\
300    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
301      newframe->Xmarkptr = markptr;\
302    newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
303    newframe->Xims = re;\    newframe->Xims = re;\
304    newframe->Xeptrb = rf;\    newframe->Xeptrb = rf;\
# Line 325  typedef struct heapframe { Line 336  typedef struct heapframe {
336    USPTR Xeptr;    USPTR Xeptr;
337    const uschar *Xecode;    const uschar *Xecode;
338    USPTR Xmstart;    USPTR Xmstart;
339      USPTR Xmarkptr;
340    int Xoffset_top;    int Xoffset_top;
341    long int Xims;    long int Xims;
342    eptrblock *Xeptrb;    eptrblock *Xeptrb;
# Line 411  the subject. */ Line 423  the subject. */
423    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\    if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\
424      {\      {\
425      md->hitend = TRUE;\      md->hitend = TRUE;\
426      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
427      }      }
428    
429  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
430    if (md->partial && eptr > mstart)\    if (md->partial != 0 && eptr > mstart)\
431      {\      {\
432      md->hitend = TRUE;\      md->hitend = TRUE;\
433      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\
434      }      }
435    
436    
# Line 432  Arguments: Line 444  Arguments:
444     ecode       pointer to current position in compiled code     ecode       pointer to current position in compiled code
445     mstart      pointer to the current match start position (can be modified     mstart      pointer to the current match start position (can be modified
446                   by encountering \K)                   by encountering \K)
447       markptr     pointer to the most recent MARK name, or NULL
448     offset_top  current top pointer     offset_top  current top pointer
449     md          pointer to "static" info for the match     md          pointer to "static" info for the match
450     ims         current /i, /m, and /s options     ims         current /i, /m, and /s options
# Line 445  Arguments: Line 458  Arguments:
458    
459  Returns:       MATCH_MATCH if matched            )  these values are >= 0  Returns:       MATCH_MATCH if matched            )  these values are >= 0
460                 MATCH_NOMATCH if failed to match  )                 MATCH_NOMATCH if failed to match  )
461                   a negative MATCH_xxx value for PRUNE, SKIP, etc
462                 a negative PCRE_ERROR_xxx value if aborted by an error condition                 a negative PCRE_ERROR_xxx value if aborted by an error condition
463                   (e.g. stopped by repeated call or recursion limit)                   (e.g. stopped by repeated call or recursion limit)
464  */  */
465    
466  static int  static int
467  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
468    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,
469    int flags, unsigned int rdepth)    eptrblock *eptrb, int flags, unsigned int rdepth)
470  {  {
471  /* 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,
472  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 480  frame->Xprevframe = NULL;            /* Line 494  frame->Xprevframe = NULL;            /*
494  frame->Xeptr = eptr;  frame->Xeptr = eptr;
495  frame->Xecode = ecode;  frame->Xecode = ecode;
496  frame->Xmstart = mstart;  frame->Xmstart = mstart;
497    frame->Xmarkptr = markptr;
498  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
499  frame->Xims = ims;  frame->Xims = ims;
500  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
# Line 495  HEAP_RECURSE: Line 510  HEAP_RECURSE:
510  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
511  #define ecode              frame->Xecode  #define ecode              frame->Xecode
512  #define mstart             frame->Xmstart  #define mstart             frame->Xmstart
513    #define markptr            frame->Xmarkptr
514  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
515  #define ims                frame->Xims  #define ims                frame->Xims
516  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
# Line 622  TAIL_RECURSE: Line 638  TAIL_RECURSE:
638  /* 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
639  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
640  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()
641  and a "return", respectively (possibly with some debugging if DEBUG is  and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
642  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
643  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,
644  however, impact performance when true recursion is being used. */  however, impact performance when true recursion is being used. */
# Line 666  for (;;) Line 682  for (;;)
682    
683    switch(op)    switch(op)
684      {      {
685        case OP_MARK:
686        markptr = ecode + 2;
687        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
688          ims, eptrb, flags, RM55);
689    
690        /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
691        argument, and we must check whether that argument matches this MARK's
692        argument. It is passed back in md->start_match_ptr (an overloading of that
693        variable). If it does match, we reset that variable to the current subject
694        position and return MATCH_SKIP. Otherwise, pass back the return code
695        unaltered. */
696    
697        if (rrc == MATCH_SKIP_ARG &&
698            strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)
699          {
700          md->start_match_ptr = eptr;
701          RRETURN(MATCH_SKIP);
702          }
703    
704        if (md->mark == NULL) md->mark = markptr;
705        RRETURN(rrc);
706    
707      case OP_FAIL:      case OP_FAIL:
708      RRETURN(MATCH_NOMATCH);      MRRETURN(MATCH_NOMATCH);
709    
710        case OP_COMMIT:
711        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
712          ims, eptrb, flags, RM52);
713        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
714        MRRETURN(MATCH_COMMIT);
715    
716      case OP_PRUNE:      case OP_PRUNE:
717      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
718        ims, eptrb, flags, RM51);        ims, eptrb, flags, RM51);
719      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
720      RRETURN(MATCH_PRUNE);      MRRETURN(MATCH_PRUNE);
721    
722      case OP_COMMIT:      case OP_PRUNE_ARG:
723      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
724        ims, eptrb, flags, RM52);        ims, eptrb, flags, RM56);
725      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
726      RRETURN(MATCH_COMMIT);      md->mark = ecode + 2;
727        RRETURN(MATCH_PRUNE);
728    
729      case OP_SKIP:      case OP_SKIP:
730      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
731        ims, eptrb, flags, RM53);        ims, eptrb, flags, RM53);
732      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
733      md->start_match_ptr = eptr;   /* Pass back current position */      md->start_match_ptr = eptr;   /* Pass back current position */
734      RRETURN(MATCH_SKIP);      MRRETURN(MATCH_SKIP);
735    
736        case OP_SKIP_ARG:
737        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
738          ims, eptrb, flags, RM57);
739        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
740    
741        /* Pass back the current skip name by overloading md->start_match_ptr and
742        returning the special MATCH_SKIP_ARG return code. This will either be
743        caught by a matching MARK, or get to the top, where it is treated the same
744        as PRUNE. */
745    
746        md->start_match_ptr = ecode + 2;
747        RRETURN(MATCH_SKIP_ARG);
748    
749      case OP_THEN:      case OP_THEN:
750      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
751        ims, eptrb, flags, RM54);        ims, eptrb, flags, RM54);
752      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
753        MRRETURN(MATCH_THEN);
754    
755        case OP_THEN_ARG:
756        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
757          ims, eptrb, flags, RM58);
758        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
759        md->mark = ecode + 2;
760      RRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
761    
762      /* Handle a capturing bracket. If there is space in the offset vector, save      /* Handle a capturing bracket. If there is space in the offset vector, save
# Line 713  for (;;) Line 778  for (;;)
778      number = GET2(ecode, 1+LINK_SIZE);      number = GET2(ecode, 1+LINK_SIZE);
779      offset = number << 1;      offset = number << 1;
780    
781  #ifdef DEBUG  #ifdef PCRE_DEBUG
782      printf("start bracket %d\n", number);      printf("start bracket %d\n", number);
783      printf("subject=");      printf("subject=");
784      pchars(eptr, 16, TRUE, md);      pchars(eptr, 16, TRUE, md);
# Line 747  for (;;) Line 812  for (;;)
812        md->offset_vector[offset+1] = save_offset2;        md->offset_vector[offset+1] = save_offset2;
813        md->offset_vector[md->offset_end - number] = save_offset3;        md->offset_vector[md->offset_end - number] = save_offset3;
814    
815          if (rrc != MATCH_THEN) md->mark = markptr;
816        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
817        }        }
818    
# Line 786  for (;;) Line 852  for (;;)
852    
853          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
854            eptrb, flags, RM48);            eptrb, flags, RM48);
855            if (rrc == MATCH_NOMATCH) md->mark = markptr;
856          RRETURN(rrc);          RRETURN(rrc);
857          }          }
858    
# Line 829  for (;;) Line 896  for (;;)
896          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
897          cb.capture_last     = md->capture_last;          cb.capture_last     = md->capture_last;
898          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
899          if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);          if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
900          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
901          }          }
902        ecode += _pcre_OP_lengths[OP_CALLOUT];        ecode += _pcre_OP_lengths[OP_CALLOUT];
# Line 839  for (;;) Line 906  for (;;)
906    
907      /* Now see what the actual condition is */      /* Now see what the actual condition is */
908    
909      if (condcode == OP_RREF)         /* Recursion test */      if (condcode == OP_RREF || condcode == OP_NRREF)    /* Recursion test */
910        {        {
911        offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/        if (md->recursive == NULL)                /* Not recursing => FALSE */
912        condition = md->recursive != NULL &&          {
913          (offset == RREF_ANY || offset == md->recursive->group_num);          condition = FALSE;
914        ecode += condition? 3 : GET(ecode, 1);          ecode += GET(ecode, 1);
915            }
916          else
917            {
918            int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
919            condition =  (recno == RREF_ANY || recno == md->recursive->group_num);
920    
921            /* If the test is for recursion into a specific subpattern, and it is
922            false, but the test was set up by name, scan the table to see if the
923            name refers to any other numbers, and test them. The condition is true
924            if any one is set. */
925    
926            if (!condition && condcode == OP_NRREF && recno != RREF_ANY)
927              {
928              uschar *slotA = md->name_table;
929              for (i = 0; i < md->name_count; i++)
930                {
931                if (GET2(slotA, 0) == recno) break;
932                slotA += md->name_entry_size;
933                }
934    
935              /* Found a name for the number - there can be only one; duplicate
936              names for different numbers are allowed, but not vice versa. First
937              scan down for duplicates. */
938    
939              if (i < md->name_count)
940                {
941                uschar *slotB = slotA;
942                while (slotB > md->name_table)
943                  {
944                  slotB -= md->name_entry_size;
945                  if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
946                    {
947                    condition = GET2(slotB, 0) == md->recursive->group_num;
948                    if (condition) break;
949                    }
950                  else break;
951                  }
952    
953                /* Scan up for duplicates */
954    
955                if (!condition)
956                  {
957                  slotB = slotA;
958                  for (i++; i < md->name_count; i++)
959                    {
960                    slotB += md->name_entry_size;
961                    if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
962                      {
963                      condition = GET2(slotB, 0) == md->recursive->group_num;
964                      if (condition) break;
965                      }
966                    else break;
967                    }
968                  }
969                }
970              }
971    
972            /* Chose branch according to the condition */
973    
974            ecode += condition? 3 : GET(ecode, 1);
975            }
976        }        }
977    
978      else if (condcode == OP_CREF)    /* Group used test */      else if (condcode == OP_CREF || condcode == OP_NCREF)  /* Group used test */
979        {        {
980        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */        offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
981        condition = offset < offset_top && md->offset_vector[offset] >= 0;        condition = offset < offset_top && md->offset_vector[offset] >= 0;
982    
983          /* If the numbered capture is unset, but the reference was by name,
984          scan the table to see if the name refers to any other numbers, and test
985          them. The condition is true if any one is set. This is tediously similar
986          to the code above, but not close enough to try to amalgamate. */
987    
988          if (!condition && condcode == OP_NCREF)
989            {
990            int refno = offset >> 1;
991            uschar *slotA = md->name_table;
992    
993            for (i = 0; i < md->name_count; i++)
994              {
995              if (GET2(slotA, 0) == refno) break;
996              slotA += md->name_entry_size;
997              }
998    
999            /* Found a name for the number - there can be only one; duplicate names
1000            for different numbers are allowed, but not vice versa. First scan down
1001            for duplicates. */
1002    
1003            if (i < md->name_count)
1004              {
1005              uschar *slotB = slotA;
1006              while (slotB > md->name_table)
1007                {
1008                slotB -= md->name_entry_size;
1009                if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1010                  {
1011                  offset = GET2(slotB, 0) << 1;
1012                  condition = offset < offset_top &&
1013                    md->offset_vector[offset] >= 0;
1014                  if (condition) break;
1015                  }
1016                else break;
1017                }
1018    
1019              /* Scan up for duplicates */
1020    
1021              if (!condition)
1022                {
1023                slotB = slotA;
1024                for (i++; i < md->name_count; i++)
1025                  {
1026                  slotB += md->name_entry_size;
1027                  if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)
1028                    {
1029                    offset = GET2(slotB, 0) << 1;
1030                    condition = offset < offset_top &&
1031                      md->offset_vector[offset] >= 0;
1032                    if (condition) break;
1033                    }
1034                  else break;
1035                  }
1036                }
1037              }
1038            }
1039    
1040          /* Chose branch according to the condition */
1041    
1042        ecode += condition? 3 : GET(ecode, 1);        ecode += condition? 3 : GET(ecode, 1);
1043        }        }
1044    
# Line 909  for (;;) Line 1097  for (;;)
1097        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
1098        }        }
1099      break;      break;
1100    
1101    
1102      /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,      /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
1103      to close any currently open capturing brackets. */      to close any currently open capturing brackets. */
1104    
1105      case OP_CLOSE:      case OP_CLOSE:
1106      number = GET2(ecode, 1);      number = GET2(ecode, 1);
1107      offset = number << 1;      offset = number << 1;
1108    
1109  #ifdef DEBUG  #ifdef PCRE_DEBUG
1110        printf("end bracket %d at *ACCEPT", number);        printf("end bracket %d at *ACCEPT", number);
1111        printf("\n");        printf("\n");
1112  #endif  #endif
# Line 932  for (;;) Line 1120  for (;;)
1120        if (offset_top <= offset) offset_top = offset + 2;        if (offset_top <= offset) offset_top = offset + 2;
1121        }        }
1122      ecode += 3;      ecode += 3;
1123      break;      break;
1124    
1125    
1126      /* 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
# Line 948  for (;;) Line 1136  for (;;)
1136        md->recursive = rec->prevrec;        md->recursive = rec->prevrec;
1137        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
1138          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
1139        offset_top = rec->offset_top;        offset_top = rec->save_offset_top;
       mstart = rec->save_start;  
1140        ims = original_ims;        ims = original_ims;
1141        ecode = rec->after_call;        ecode = rec->after_call;
1142        break;        break;
# Line 964  for (;;) Line 1151  for (;;)
1151          (md->notempty ||          (md->notempty ||
1152            (md->notempty_atstart &&            (md->notempty_atstart &&
1153              mstart == md->start_subject + md->start_offset)))              mstart == md->start_subject + md->start_offset)))
1154        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1155    
1156      /* Otherwise, we have a match. */      /* Otherwise, we have a match. */
1157    
1158      md->end_match_ptr = eptr;           /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
1159      md->end_offset_top = offset_top;    /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
1160      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
1161      RRETURN(MATCH_MATCH);  
1162        /* For some reason, the macros don't work properly if an expression is
1163        given as the argument to MRRETURN when the heap is in use. */
1164    
1165        rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1166        MRRETURN(rrc);
1167    
1168      /* Change option settings */      /* Change option settings */
1169    
# Line 993  for (;;) Line 1185  for (;;)
1185        {        {
1186        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1187          RM4);          RM4);
1188        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1189            {
1190            mstart = md->start_match_ptr;   /* In case \K reset it */
1191            break;
1192            }
1193        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1194        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1195        }        }
1196      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1197      if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);      if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);
1198    
1199      /* If checking an assertion for a condition, return MATCH_MATCH. */      /* If checking an assertion for a condition, return MATCH_MATCH. */
1200    
# Line 1012  for (;;) Line 1208  for (;;)
1208      offset_top = md->end_offset_top;      offset_top = md->end_offset_top;
1209      continue;      continue;
1210    
1211      /* Negative assertion: all branches must fail to match */      /* Negative assertion: all branches must fail to match. Encountering SKIP,
1212        PRUNE, or COMMIT means we must assume failure without checking subsequent
1213        branches. */
1214    
1215      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1216      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
# Line 1020  for (;;) Line 1218  for (;;)
1218        {        {
1219        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
1220          RM5);          RM5);
1221        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);
1222          if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1223            {
1224            do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1225            break;
1226            }
1227        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1228        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1229        }        }
# Line 1044  for (;;) Line 1247  for (;;)
1247        while (i-- > 0)        while (i-- > 0)
1248          {          {
1249          eptr--;          eptr--;
1250          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1251          BACKCHAR(eptr);          BACKCHAR(eptr);
1252          }          }
1253        }        }
# Line 1055  for (;;) Line 1258  for (;;)
1258    
1259        {        {
1260        eptr -= GET(ecode, 1);        eptr -= GET(ecode, 1);
1261        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);
1262        }        }
1263    
1264      /* Save the earliest consulted character, then skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
# Line 1084  for (;;) Line 1287  for (;;)
1287        cb.capture_top      = offset_top/2;        cb.capture_top      = offset_top/2;
1288        cb.capture_last     = md->capture_last;        cb.capture_last     = md->capture_last;
1289        cb.callout_data     = md->callout_data;        cb.callout_data     = md->callout_data;
1290        if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);        if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);
1291        if (rrc < 0) RRETURN(rrc);        if (rrc < 0) RRETURN(rrc);
1292        }        }
1293      ecode += 2 + 2*LINK_SIZE;      ecode += 2 + 2*LINK_SIZE;
# Line 1139  for (;;) Line 1342  for (;;)
1342    
1343        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1344              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
1345        new_recursive.save_start = mstart;        new_recursive.save_offset_top = offset_top;
       new_recursive.offset_top = offset_top;  
       mstart = eptr;  
1346    
1347        /* 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
1348        restore the offset and recursion data. */        restore the offset and recursion data. */
# Line 1152  for (;;) Line 1353  for (;;)
1353          {          {
1354          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,
1355            md, ims, eptrb, flags, RM6);            md, ims, eptrb, flags, RM6);
1356          if (rrc == MATCH_MATCH)          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1357            {            {
1358            DPRINTF(("Recursion matched\n"));            DPRINTF(("Recursion matched\n"));
1359            md->recursive = new_recursive.prevrec;            md->recursive = new_recursive.prevrec;
1360            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1361              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1362            RRETURN(MATCH_MATCH);            MRRETURN(MATCH_MATCH);
1363            }            }
1364          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1365            {            {
# Line 1179  for (;;) Line 1380  for (;;)
1380        md->recursive = new_recursive.prevrec;        md->recursive = new_recursive.prevrec;
1381        if (new_recursive.offset_save != stacksave)        if (new_recursive.offset_save != stacksave)
1382          (pcre_free)(new_recursive.offset_save);          (pcre_free)(new_recursive.offset_save);
1383        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1384        }        }
1385      /* Control never reaches here */      /* Control never reaches here */
1386    
# Line 1188  for (;;) Line 1389  for (;;)
1389      a move back into the brackets. Friedl calls these "atomic" subpatterns.      a move back into the brackets. Friedl calls these "atomic" subpatterns.
1390      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
1391      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
1392      the end of a normal bracket, leaving the subject pointer. */      the end of a normal bracket, leaving the subject pointer, but resetting
1393        the start-of-match value in case it was changed by \K. */
1394    
1395      case OP_ONCE:      case OP_ONCE:
1396      prev = ecode;      prev = ecode;
# Line 1197  for (;;) Line 1399  for (;;)
1399      do      do
1400        {        {
1401        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);
1402        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
1403            {
1404            mstart = md->start_match_ptr;
1405            break;
1406            }
1407        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1408        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1409        }        }
# Line 1316  for (;;) Line 1522  for (;;)
1522        }        }
1523      else saved_eptr = NULL;      else saved_eptr = NULL;
1524    
1525      /* 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
1526      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
1527      assertions. Do this also for the "once" (atomic) groups. */      use by positive assertions. We also need to record the match start in case
1528        it was changed by \K. */
1529    
1530      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
1531          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
# Line 1326  for (;;) Line 1533  for (;;)
1533        {        {
1534        md->end_match_ptr = eptr;      /* For ONCE */        md->end_match_ptr = eptr;      /* For ONCE */
1535        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
1536        RRETURN(MATCH_MATCH);        md->start_match_ptr = mstart;
1537          MRRETURN(MATCH_MATCH);
1538        }        }
1539    
1540      /* 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 1339  for (;;) Line 1547  for (;;)
1547        {        {
1548        number = GET2(prev, 1+LINK_SIZE);        number = GET2(prev, 1+LINK_SIZE);
1549        offset = number << 1;        offset = number << 1;
1550    
1551  #ifdef DEBUG  #ifdef PCRE_DEBUG
1552        printf("end bracket %d", number);        printf("end bracket %d", number);
1553        printf("\n");        printf("\n");
1554  #endif  #endif
# Line 1362  for (;;) Line 1570  for (;;)
1570          recursion_info *rec = md->recursive;          recursion_info *rec = md->recursive;
1571          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1572          md->recursive = rec->prevrec;          md->recursive = rec->prevrec;
         mstart = rec->save_start;  
1573          memcpy(md->offset_vector, rec->offset_save,          memcpy(md->offset_vector, rec->offset_save,
1574            rec->saved_max * sizeof(int));            rec->saved_max * sizeof(int));
1575          offset_top = rec->offset_top;          offset_top = rec->save_offset_top;
1576          ecode = rec->after_call;          ecode = rec->after_call;
1577          ims = original_ims;          ims = original_ims;
1578          break;          break;
# Line 1422  for (;;) Line 1629  for (;;)
1629      /* Start of subject unless notbol, or after internal newline if multiline */      /* Start of subject unless notbol, or after internal newline if multiline */
1630    
1631      case OP_CIRC:      case OP_CIRC:
1632      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);
1633      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1634        {        {
1635        if (eptr != md->start_subject &&        if (eptr != md->start_subject &&
1636            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))            (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1637          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1638        ecode++;        ecode++;
1639        break;        break;
1640        }        }
# Line 1436  for (;;) Line 1643  for (;;)
1643      /* Start of subject assertion */      /* Start of subject assertion */
1644    
1645      case OP_SOD:      case OP_SOD:
1646      if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);
1647      ecode++;      ecode++;
1648      break;      break;
1649    
1650      /* Start of match assertion */      /* Start of match assertion */
1651    
1652      case OP_SOM:      case OP_SOM:
1653      if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);
1654      ecode++;      ecode++;
1655      break;      break;
1656    
# Line 1461  for (;;) Line 1668  for (;;)
1668      if ((ims & PCRE_MULTILINE) != 0)      if ((ims & PCRE_MULTILINE) != 0)
1669        {        {
1670        if (eptr < md->end_subject)        if (eptr < md->end_subject)
1671          { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }          { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }
1672        else        else
1673          { if (md->noteol) RRETURN(MATCH_NOMATCH); }          { if (md->noteol) MRRETURN(MATCH_NOMATCH); }
1674        ecode++;        ecode++;
1675        break;        break;
1676        }        }
1677      else      else
1678        {        {
1679        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) MRRETURN(MATCH_NOMATCH);
1680        if (!md->endonly)        if (!md->endonly)
1681          {          {
1682          if (eptr != md->end_subject &&          if (eptr != md->end_subject &&
1683              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))              (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1684            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
1685          ecode++;          ecode++;
1686          break;          break;
1687          }          }
# Line 1484  for (;;) Line 1691  for (;;)
1691      /* End of subject assertion (\z) */      /* End of subject assertion (\z) */
1692    
1693      case OP_EOD:      case OP_EOD:
1694      if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);
1695      ecode++;      ecode++;
1696      break;      break;
1697    
# Line 1493  for (;;) Line 1700  for (;;)
1700      case OP_EODN:      case OP_EODN:
1701      if (eptr != md->end_subject &&      if (eptr != md->end_subject &&
1702          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
1703        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1704      ecode++;      ecode++;
1705      break;      break;
1706    
# Line 1553  for (;;) Line 1760  for (;;)
1760    
1761        if ((*ecode++ == OP_WORD_BOUNDARY)?        if ((*ecode++ == OP_WORD_BOUNDARY)?
1762             cur_is_word == prev_is_word : cur_is_word != prev_is_word)             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
1763          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
1764        }        }
1765      break;      break;
1766    
1767      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1768    
1769      case OP_ANY:      case OP_ANY:
1770      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
1771      /* Fall through */      /* Fall through */
1772    
1773      case OP_ALLANY:      case OP_ALLANY:
1774      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1775        {        {
1776        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1777        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1778        }        }
1779      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
1780      ecode++;      ecode++;
# Line 1580  for (;;) Line 1787  for (;;)
1787      if (eptr++ >= md->end_subject)      if (eptr++ >= md->end_subject)
1788        {        {
1789        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1790        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1791        }        }
1792      ecode++;      ecode++;
1793      break;      break;
# Line 1589  for (;;) Line 1796  for (;;)
1796      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1797        {        {
1798        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1799        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1800        }        }
1801      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1802      if (      if (
# Line 1598  for (;;) Line 1805  for (;;)
1805  #endif  #endif
1806         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
1807         )         )
1808        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1809      ecode++;      ecode++;
1810      break;      break;
1811    
# Line 1606  for (;;) Line 1813  for (;;)
1813      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1814        {        {
1815        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1816        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1817        }        }
1818      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1819      if (      if (
# Line 1615  for (;;) Line 1822  for (;;)
1822  #endif  #endif
1823         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
1824         )         )
1825        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1826      ecode++;      ecode++;
1827      break;      break;
1828    
# Line 1623  for (;;) Line 1830  for (;;)
1830      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1831        {        {
1832        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1833        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1834        }        }
1835      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1836      if (      if (
# Line 1632  for (;;) Line 1839  for (;;)
1839  #endif  #endif
1840         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
1841         )         )
1842        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1843      ecode++;      ecode++;
1844      break;      break;
1845    
# Line 1640  for (;;) Line 1847  for (;;)
1847      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1848        {        {
1849        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1850        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1851        }        }
1852      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1853      if (      if (
# Line 1649  for (;;) Line 1856  for (;;)
1856  #endif  #endif
1857         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
1858         )         )
1859        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1860      ecode++;      ecode++;
1861      break;      break;
1862    
# Line 1657  for (;;) Line 1864  for (;;)
1864      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1865        {        {
1866        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1867        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1868        }        }
1869      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1870      if (      if (
# Line 1666  for (;;) Line 1873  for (;;)
1873  #endif  #endif
1874         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
1875         )         )
1876        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1877      ecode++;      ecode++;
1878      break;      break;
1879    
# Line 1674  for (;;) Line 1881  for (;;)
1881      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1882        {        {
1883        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1884        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1885        }        }
1886      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1887      if (      if (
# Line 1683  for (;;) Line 1890  for (;;)
1890  #endif  #endif
1891         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
1892         )         )
1893        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1894      ecode++;      ecode++;
1895      break;      break;
1896    
# Line 1691  for (;;) Line 1898  for (;;)
1898      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1899        {        {
1900        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1901        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1902        }        }
1903      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1904      switch(c)      switch(c)
1905        {        {
1906        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
1907        case 0x000d:        case 0x000d:
1908        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1909        break;        break;
# Line 1709  for (;;) Line 1916  for (;;)
1916        case 0x0085:        case 0x0085:
1917        case 0x2028:        case 0x2028:
1918        case 0x2029:        case 0x2029:
1919        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
1920        break;        break;
1921        }        }
1922      ecode++;      ecode++;
# Line 1719  for (;;) Line 1926  for (;;)
1926      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1927        {        {
1928        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1929        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1930        }        }
1931      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1932      switch(c)      switch(c)
# Line 1744  for (;;) Line 1951  for (;;)
1951        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
1952        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1953        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
1954        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1955        }        }
1956      ecode++;      ecode++;
1957      break;      break;
# Line 1753  for (;;) Line 1960  for (;;)
1960      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1961        {        {
1962        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1963        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1964        }        }
1965      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1966      switch(c)      switch(c)
1967        {        {
1968        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
1969        case 0x09:      /* HT */        case 0x09:      /* HT */
1970        case 0x20:      /* SPACE */        case 0x20:      /* SPACE */
1971        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
# Line 1787  for (;;) Line 1994  for (;;)
1994      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
1995        {        {
1996        SCHECK_PARTIAL();        SCHECK_PARTIAL();
1997        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
1998        }        }
1999      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2000      switch(c)      switch(c)
# Line 1800  for (;;) Line 2007  for (;;)
2007        case 0x85:      /* NEL */        case 0x85:      /* NEL */
2008        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2009        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2010        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2011        }        }
2012      ecode++;      ecode++;
2013      break;      break;
# Line 1809  for (;;) Line 2016  for (;;)
2016      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2017        {        {
2018        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2019        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2020        }        }
2021      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2022      switch(c)      switch(c)
2023        {        {
2024        default: RRETURN(MATCH_NOMATCH);        default: MRRETURN(MATCH_NOMATCH);
2025        case 0x0a:      /* LF */        case 0x0a:      /* LF */
2026        case 0x0b:      /* VT */        case 0x0b:      /* VT */
2027        case 0x0c:      /* FF */        case 0x0c:      /* FF */
# Line 1836  for (;;) Line 2043  for (;;)
2043      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2044        {        {
2045        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2046        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2047        }        }
2048      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2049        {        {
# Line 1845  for (;;) Line 2052  for (;;)
2052        switch(ecode[1])        switch(ecode[1])
2053          {          {
2054          case PT_ANY:          case PT_ANY:
2055          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);          if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);
2056          break;          break;
2057    
2058          case PT_LAMP:          case PT_LAMP:
2059          if ((prop->chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
2060               prop->chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
2061               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2062            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2063           break;          break;
2064    
2065          case PT_GC:          case PT_GC:
2066          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2067            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2068          break;          break;
2069    
2070          case PT_PC:          case PT_PC:
2071          if ((ecode[2] != prop->chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2072            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2073          break;          break;
2074    
2075          case PT_SC:          case PT_SC:
2076          if ((ecode[2] != prop->script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
2077            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2078          break;          break;
2079    
2080            /* These are specials */
2081    
2082            case PT_ALNUM:
2083            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2084                 _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2085              MRRETURN(MATCH_NOMATCH);
2086            break;
2087    
2088            case PT_SPACE:    /* Perl space */
2089            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2090                 c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2091                   == (op == OP_NOTPROP))
2092              MRRETURN(MATCH_NOMATCH);
2093            break;
2094    
2095            case PT_PXSPACE:  /* POSIX space */
2096            if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2097                 c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2098                 c == CHAR_FF || c == CHAR_CR)
2099                   == (op == OP_NOTPROP))
2100              MRRETURN(MATCH_NOMATCH);
2101            break;
2102    
2103            case PT_WORD:
2104            if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2105                 _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2106                 c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2107              MRRETURN(MATCH_NOMATCH);
2108            break;
2109    
2110            /* This should never occur */
2111    
2112          default:          default:
2113          RRETURN(PCRE_ERROR_INTERNAL);          RRETURN(PCRE_ERROR_INTERNAL);
# Line 1885  for (;;) Line 2124  for (;;)
2124      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2125        {        {
2126        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2127        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2128        }        }
2129      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2130        {        {
2131        int category = UCD_CATEGORY(c);        int category = UCD_CATEGORY(c);
2132        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) MRRETURN(MATCH_NOMATCH);
2133        while (eptr < md->end_subject)        while (eptr < md->end_subject)
2134          {          {
2135          int len = 1;          int len = 1;
# Line 1969  for (;;) Line 2208  for (;;)
2208          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2209            {            {
2210            CHECK_PARTIAL();            CHECK_PARTIAL();
2211            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2212            }            }
2213          eptr += length;          eptr += length;
2214          continue;              /* With the main loop */          continue;              /* With the main loop */
# Line 1989  for (;;) Line 2228  for (;;)
2228          if (!match_ref(offset, eptr, length, md, ims))          if (!match_ref(offset, eptr, length, md, ims))
2229            {            {
2230            CHECK_PARTIAL();            CHECK_PARTIAL();
2231            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2232            }            }
2233          eptr += length;          eptr += length;
2234          }          }
# Line 2007  for (;;) Line 2246  for (;;)
2246            {            {
2247            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14);
2248            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2249            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2250            if (!match_ref(offset, eptr, length, md, ims))            if (!match_ref(offset, eptr, length, md, ims))
2251              {              {
2252              CHECK_PARTIAL();              CHECK_PARTIAL();
2253              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2254              }              }
2255            eptr += length;            eptr += length;
2256            }            }
# Line 2025  for (;;) Line 2264  for (;;)
2264          pp = eptr;          pp = eptr;
2265          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2266            {            {
2267            if (!match_ref(offset, eptr, length, md, ims)) break;            if (!match_ref(offset, eptr, length, md, ims))
2268                {
2269                CHECK_PARTIAL();
2270                break;
2271                }
2272            eptr += length;            eptr += length;
2273            }            }
2274          while (eptr >= pp)          while (eptr >= pp)
# Line 2034  for (;;) Line 2277  for (;;)
2277            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2278            eptr -= length;            eptr -= length;
2279            }            }
2280          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2281          }          }
2282        }        }
2283      /* Control never gets here */      /* Control never gets here */
# Line 2096  for (;;) Line 2339  for (;;)
2339            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2340              {              {
2341              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2342              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2343              }              }
2344            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2345            if (c > 255)            if (c > 255)
2346              {              {
2347              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2348              }              }
2349            else            else
2350              {              {
2351              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2352              }              }
2353            }            }
2354          }          }
# Line 2118  for (;;) Line 2361  for (;;)
2361            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2362              {              {
2363              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2364              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2365              }              }
2366            c = *eptr++;            c = *eptr++;
2367            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2368            }            }
2369          }          }
2370    
# Line 2143  for (;;) Line 2386  for (;;)
2386              {              {
2387              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16);
2388              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2389              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2390              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2391                {                {
2392                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2393                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2394                }                }
2395              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2396              if (c > 255)              if (c > 255)
2397                {                {
2398                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);
2399                }                }
2400              else              else
2401                {                {
2402                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2403                }                }
2404              }              }
2405            }            }
# Line 2168  for (;;) Line 2411  for (;;)
2411              {              {
2412              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17);
2413              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2414              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2415              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2416                {                {
2417                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2418                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2419                }                }
2420              c = *eptr++;              c = *eptr++;
2421              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);
2422              }              }
2423            }            }
2424          /* Control never gets here */          /* Control never gets here */
# Line 2194  for (;;) Line 2437  for (;;)
2437            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2438              {              {
2439              int len = 1;              int len = 1;
2440              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
2441                  {
2442                  SCHECK_PARTIAL();
2443                  break;
2444                  }
2445              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
2446              if (c > 255)              if (c > 255)
2447                {                {
# Line 2220  for (;;) Line 2467  for (;;)
2467            {            {
2468            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2469              {              {
2470              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
2471                  {
2472                  SCHECK_PARTIAL();
2473                  break;
2474                  }
2475              c = *eptr;              c = *eptr;
2476              if ((data[c/8] & (1 << (c&7))) == 0) break;              if ((data[c/8] & (1 << (c&7))) == 0) break;
2477              eptr++;              eptr++;
# Line 2233  for (;;) Line 2484  for (;;)
2484              }              }
2485            }            }
2486    
2487          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2488          }          }
2489        }        }
2490      /* Control never gets here */      /* Control never gets here */
# Line 2285  for (;;) Line 2536  for (;;)
2536          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2537            {            {
2538            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2539            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2540            }            }
2541          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2542          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2543          }          }
2544    
2545        /* 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 2305  for (;;) Line 2556  for (;;)
2556            {            {
2557            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2558            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2559            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2560            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2561              {              {
2562              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2563              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2564              }              }
2565            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2566            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);
2567            }            }
2568          /* Control never gets here */          /* Control never gets here */
2569          }          }
# Line 2325  for (;;) Line 2576  for (;;)
2576          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2577            {            {
2578            int len = 1;            int len = 1;
2579            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject)
2580                {
2581                SCHECK_PARTIAL();
2582                break;
2583                }
2584            GETCHARLENTEST(c, eptr, len);            GETCHARLENTEST(c, eptr, len);
2585            if (!_pcre_xclass(c, data)) break;            if (!_pcre_xclass(c, data)) break;
2586            eptr += len;            eptr += len;
# Line 2337  for (;;) Line 2592  for (;;)
2592            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2593            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2594            }            }
2595          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2596          }          }
2597    
2598        /* Control never gets here */        /* Control never gets here */
# Line 2356  for (;;) Line 2611  for (;;)
2611        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2612          {          {
2613          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2614          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2615          }          }
2616        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);
2617        }        }
2618      else      else
2619  #endif  #endif
# Line 2368  for (;;) Line 2623  for (;;)
2623        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2624          {          {
2625          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2626          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2627          }          }
2628        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);
2629        ecode += 2;        ecode += 2;
2630        }        }
2631      break;      break;
# Line 2388  for (;;) Line 2643  for (;;)
2643        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
2644          {          {
2645          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
2646          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2647          }          }
2648    
2649        /* If the pattern character's value is < 128, we have only one byte, and        /* If the pattern character's value is < 128, we have only one byte, and
# Line 2396  for (;;) Line 2651  for (;;)
2651    
2652        if (fc < 128)        if (fc < 128)
2653          {          {
2654          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2655          }          }
2656    
2657        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 2415  for (;;) Line 2670  for (;;)
2670  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2671            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
2672  #endif  #endif
2673              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2674            }            }
2675          }          }
2676        }        }
# Line 2427  for (;;) Line 2682  for (;;)
2682        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
2683          {          {
2684          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
2685          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2686          }          }
2687        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2688        ecode += 2;        ecode += 2;
2689        }        }
2690      break;      break;
# Line 2523  for (;;) Line 2778  for (;;)
2778            else            else
2779              {              {
2780              CHECK_PARTIAL();              CHECK_PARTIAL();
2781              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2782              }              }
2783            }            }
2784    
# Line 2535  for (;;) Line 2790  for (;;)
2790              {              {
2791              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22);
2792              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2793              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
2794              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
2795                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
2796  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2546  for (;;) Line 2801  for (;;)
2801              else              else
2802                {                {
2803                CHECK_PARTIAL();                CHECK_PARTIAL();
2804                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
2805                }                }
2806              }              }
2807            /* Control never gets here */            /* Control never gets here */
# Line 2564  for (;;) Line 2819  for (;;)
2819                       eptr <= md->end_subject - oclength &&                       eptr <= md->end_subject - oclength &&
2820                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;
2821  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
2822              else break;              else
2823                  {
2824                  CHECK_PARTIAL();
2825                  break;
2826                  }
2827              }              }
2828    
2829            if (possessive) continue;            if (possessive) continue;
# Line 2573  for (;;) Line 2832  for (;;)
2832              {              {
2833              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23);
2834              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2835              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }
2836  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2837              eptr--;              eptr--;
2838              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 2616  for (;;) Line 2875  for (;;)
2875          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2876            {            {
2877            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2878            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2879            }            }
2880          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2881          }          }
2882        if (min == max) continue;        if (min == max) continue;
2883        if (minimize)        if (minimize)
# Line 2627  for (;;) Line 2886  for (;;)
2886            {            {
2887            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24);
2888            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2889            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2890            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2891              {              {
2892              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2893              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2894              }              }
2895            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
2896            }            }
2897          /* Control never gets here */          /* Control never gets here */
2898          }          }
# Line 2642  for (;;) Line 2901  for (;;)
2901          pp = eptr;          pp = eptr;
2902          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2903            {            {
2904            if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;            if (eptr >= md->end_subject)
2905                {
2906                SCHECK_PARTIAL();
2907                break;
2908                }
2909              if (fc != md->lcc[*eptr]) break;
2910            eptr++;            eptr++;
2911            }            }
2912    
# Line 2654  for (;;) Line 2918  for (;;)
2918            eptr--;            eptr--;
2919            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2920            }            }
2921          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2922          }          }
2923        /* Control never gets here */        /* Control never gets here */
2924        }        }
# Line 2668  for (;;) Line 2932  for (;;)
2932          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2933            {            {
2934            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2935            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
2936            }            }
2937          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
2938          }          }
2939    
2940        if (min == max) continue;        if (min == max) continue;
# Line 2681  for (;;) Line 2945  for (;;)
2945            {            {
2946            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26);
2947            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2948            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
2949            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2950              {              {
2951              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2952              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
2953              }              }
2954            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);
2955            }            }
2956          /* Control never gets here */          /* Control never gets here */
2957          }          }
# Line 2696  for (;;) Line 2960  for (;;)
2960          pp = eptr;          pp = eptr;
2961          for (i = min; i < max; i++)          for (i = min; i < max; i++)
2962            {            {
2963            if (eptr >= md->end_subject || fc != *eptr) break;            if (eptr >= md->end_subject)
2964                {
2965                SCHECK_PARTIAL();
2966                break;
2967                }
2968              if (fc != *eptr) break;
2969            eptr++;            eptr++;
2970            }            }
2971          if (possessive) continue;          if (possessive) continue;
# Line 2707  for (;;) Line 2976  for (;;)
2976            eptr--;            eptr--;
2977            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2978            }            }
2979          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
2980          }          }
2981        }        }
2982      /* Control never gets here */      /* Control never gets here */
# Line 2719  for (;;) Line 2988  for (;;)
2988      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2989        {        {
2990        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2991        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
2992        }        }
2993      ecode++;      ecode++;
2994      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
# Line 2729  for (;;) Line 2998  for (;;)
2998        if (c < 256)        if (c < 256)
2999  #endif  #endif
3000        c = md->lcc[c];        c = md->lcc[c];
3001        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);
3002        }        }
3003      else      else
3004        {        {
3005        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);
3006        }        }
3007      break;      break;
3008    
# Line 2827  for (;;) Line 3096  for (;;)
3096            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3097              {              {
3098              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3099              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3100              }              }
3101            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3102            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3103            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3104            }            }
3105          }          }
3106        else        else
# Line 2844  for (;;) Line 3113  for (;;)
3113            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3114              {              {
3115              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3116              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3117              }              }
3118            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3119            }            }
3120          }          }
3121    
# Line 2863  for (;;) Line 3132  for (;;)
3132              {              {
3133              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
3134              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3135              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3136              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3137                {                {
3138                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3139                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3140                }                }
3141              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3142              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3143              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3144              }              }
3145            }            }
3146          else          else
# Line 2882  for (;;) Line 3151  for (;;)
3151              {              {
3152              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29);
3153              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3154              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3155              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3156                {                {
3157                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3158                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3159                }                }
3160              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);
3161              }              }
3162            }            }
3163          /* Control never gets here */          /* Control never gets here */
# Line 2908  for (;;) Line 3177  for (;;)
3177            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3178              {              {
3179              int len = 1;              int len = 1;
3180              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
3181                  {
3182                  SCHECK_PARTIAL();
3183                  break;
3184                  }
3185              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3186              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3187              if (fc == d) break;              if (fc == d) break;
# Line 2929  for (;;) Line 3202  for (;;)
3202            {            {
3203            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3204              {              {
3205              if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;              if (eptr >= md->end_subject)
3206                  {
3207                  SCHECK_PARTIAL();
3208                  break;
3209                  }
3210                if (fc == md->lcc[*eptr]) break;
3211              eptr++;              eptr++;
3212              }              }
3213            if (possessive) continue;            if (possessive) continue;
# Line 2941  for (;;) Line 3219  for (;;)
3219              }              }
3220            }            }
3221    
3222          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3223          }          }
3224        /* Control never gets here */        /* Control never gets here */
3225        }        }
# Line 2960  for (;;) Line 3238  for (;;)
3238            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3239              {              {
3240              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3241              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3242              }              }
3243            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3244            if (fc == d) RRETURN(MATCH_NOMATCH);            if (fc == d) MRRETURN(MATCH_NOMATCH);
3245            }            }
3246          }          }
3247        else        else
# Line 2975  for (;;) Line 3253  for (;;)
3253            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3254              {              {
3255              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3256              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3257              }              }
3258            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3259            }            }
3260          }          }
3261    
# Line 2994  for (;;) Line 3272  for (;;)
3272              {              {
3273              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
3274              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3275              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3276              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3277                {                {
3278                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3279                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3280                }                }
3281              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3282              if (fc == d) RRETURN(MATCH_NOMATCH);              if (fc == d) MRRETURN(MATCH_NOMATCH);
3283              }              }
3284            }            }
3285          else          else
# Line 3012  for (;;) Line 3290  for (;;)
3290              {              {
3291              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33);
3292              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3293              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
3294              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3295                {                {
3296                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3297                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3298                }                }
3299              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);
3300              }              }
3301            }            }
3302          /* Control never gets here */          /* Control never gets here */
# Line 3038  for (;;) Line 3316  for (;;)
3316            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3317              {              {
3318              int len = 1;              int len = 1;
3319              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
3320                  {
3321                  SCHECK_PARTIAL();
3322                  break;
3323                  }
3324              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3325              if (fc == d) break;              if (fc == d) break;
3326              eptr += len;              eptr += len;
# Line 3058  for (;;) Line 3340  for (;;)
3340            {            {
3341            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3342              {              {
3343              if (eptr >= md->end_subject || fc == *eptr) break;              if (eptr >= md->end_subject)
3344                  {
3345                  SCHECK_PARTIAL();
3346                  break;
3347                  }
3348                if (fc == *eptr) break;
3349              eptr++;              eptr++;
3350              }              }
3351            if (possessive) continue;            if (possessive) continue;
# Line 3070  for (;;) Line 3357  for (;;)
3357              }              }
3358            }            }
3359    
3360          RRETURN(MATCH_NOMATCH);          MRRETURN(MATCH_NOMATCH);
3361          }          }
3362        }        }
3363      /* Control never gets here */      /* Control never gets here */
# Line 3164  for (;;) Line 3451  for (;;)
3451          switch(prop_type)          switch(prop_type)
3452            {            {
3453            case PT_ANY:            case PT_ANY:
3454            if (prop_fail_result) RRETURN(MATCH_NOMATCH);            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
3455            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3456              {              {
3457              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3458                {                {
3459                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3460                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3461                }                }
3462              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3463              }              }
# Line 3182  for (;;) Line 3469  for (;;)
3469              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3470                {                {
3471                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3472                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3473                }                }
3474              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3475              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3476              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3477                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3478                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
3479                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3480              }              }
3481            break;            break;
3482    
# Line 3199  for (;;) Line 3486  for (;;)
3486              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3487                {                {
3488                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3489                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3490                }                }
3491              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3492              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
3493              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3494                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3495              }              }
3496            break;            break;
3497    
# Line 3214  for (;;) Line 3501  for (;;)
3501              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3502                {                {
3503                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3504                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3505                }                }
3506              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3507              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
3508              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3509                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3510              }              }
3511            break;            break;
3512    
# Line 3229  for (;;) Line 3516  for (;;)
3516              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3517                {                {
3518                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3519                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3520                }                }
3521              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3522              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
3523              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3524                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
3525                }
3526              break;
3527    
3528              case PT_ALNUM:
3529              for (i = 1; i <= min; i++)
3530                {
3531                if (eptr >= md->end_subject)
3532                  {
3533                  SCHECK_PARTIAL();
3534                  MRRETURN(MATCH_NOMATCH);
3535                  }
3536                GETCHARINCTEST(c, eptr);
3537                prop_category = UCD_CATEGORY(c);
3538                if ((prop_category == ucp_L || prop_category == ucp_N)
3539                       == prop_fail_result)
3540                  MRRETURN(MATCH_NOMATCH);
3541              }              }
3542            break;            break;
3543    
3544              case PT_SPACE:    /* Perl space */
3545              for (i = 1; i <= min; i++)
3546                {
3547                if (eptr >= md->end_subject)
3548                  {
3549                  SCHECK_PARTIAL();
3550                  MRRETURN(MATCH_NOMATCH);
3551                  }
3552                GETCHARINCTEST(c, eptr);
3553                prop_category = UCD_CATEGORY(c);
3554                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3555                     c == CHAR_FF || c == CHAR_CR)
3556                       == prop_fail_result)
3557                  MRRETURN(MATCH_NOMATCH);
3558                }
3559              break;
3560    
3561              case PT_PXSPACE:  /* POSIX space */
3562              for (i = 1; i <= min; i++)
3563                {
3564                if (eptr >= md->end_subject)
3565                  {
3566                  SCHECK_PARTIAL();
3567                  MRRETURN(MATCH_NOMATCH);
3568                  }
3569                GETCHARINCTEST(c, eptr);
3570                prop_category = UCD_CATEGORY(c);
3571                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3572                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
3573                       == prop_fail_result)
3574                  MRRETURN(MATCH_NOMATCH);
3575                }
3576              break;
3577    
3578              case PT_WORD:
3579              for (i = 1; i <= min; i++)
3580                {
3581                if (eptr >= md->end_subject)
3582                  {
3583                  SCHECK_PARTIAL();
3584                  MRRETURN(MATCH_NOMATCH);
3585                  }
3586                GETCHARINCTEST(c, eptr);
3587                prop_category = UCD_CATEGORY(c);
3588                if ((prop_category == ucp_L || prop_category == ucp_N ||
3589                     c == CHAR_UNDERSCORE)
3590                       == prop_fail_result)
3591                  MRRETURN(MATCH_NOMATCH);
3592                }
3593              break;
3594    
3595              /* This should not occur */
3596    
3597            default:            default:
3598            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
# Line 3253  for (;;) Line 3609  for (;;)
3609            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3610              {              {
3611              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3612              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3613              }              }
3614            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3615            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
3616            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
3617            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3618              {              {
3619              int len = 1;              int len = 1;
# Line 3284  for (;;) Line 3640  for (;;)
3640            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3641              {              {
3642              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3643              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3644              }              }
3645            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3646            eptr++;            eptr++;
3647            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3648            }            }
# Line 3298  for (;;) Line 3654  for (;;)
3654            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3655              {              {
3656              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3657              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3658              }              }
3659            eptr++;            eptr++;
3660            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3306  for (;;) Line 3662  for (;;)
3662          break;          break;
3663    
3664          case OP_ANYBYTE:          case OP_ANYBYTE:
3665          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);
3666          eptr += min;          eptr += min;
3667          break;          break;
3668    
# Line 3316  for (;;) Line 3672  for (;;)
3672            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3673              {              {
3674              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3675              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3676              }              }
3677            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3678            switch(c)            switch(c)
3679              {              {
3680              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3681              case 0x000d:              case 0x000d:
3682              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3683              break;              break;
# Line 3334  for (;;) Line 3690  for (;;)
3690              case 0x0085:              case 0x0085:
3691              case 0x2028:              case 0x2028:
3692              case 0x2029:              case 0x2029:
3693              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3694              break;              break;
3695              }              }
3696            }            }
# Line 3346  for (;;) Line 3702  for (;;)
3702            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3703              {              {
3704              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3705              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3706              }              }
3707            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3708            switch(c)            switch(c)
# Line 3371  for (;;) Line 3727  for (;;)
3727              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
3728              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3729              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
3730              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3731              }              }
3732            }            }
3733          break;          break;
# Line 3382  for (;;) Line 3738  for (;;)
3738            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3739              {              {
3740              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3741              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3742              }              }
3743            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3744            switch(c)            switch(c)
3745              {              {
3746              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3747              case 0x09:      /* HT */              case 0x09:      /* HT */
3748              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3749              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3418  for (;;) Line 3774  for (;;)
3774            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3775              {              {
3776              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3777              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3778              }              }
3779            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3780            switch(c)            switch(c)
# Line 3431  for (;;) Line 3787  for (;;)
3787              case 0x85:      /* NEL */              case 0x85:      /* NEL */
3788              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
3789              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
3790              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3791              }              }
3792            }            }
3793          break;          break;
# Line 3442  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 0x0a:      /* LF */              case 0x0a:      /* LF */
3808              case 0x0b:      /* VT */              case 0x0b:      /* VT */
3809              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3466  for (;;) Line 3822  for (;;)
3822            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3823              {              {
3824              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3825              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3826              }              }
3827            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3828            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
3829              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3830            }            }
3831          break;          break;
3832    
# Line 3480  for (;;) Line 3836  for (;;)
3836            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3837              {              {
3838              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3839              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3840              }              }
3841            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
3842              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3843            /* 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 */
3844            }            }
3845          break;          break;
# Line 3494  for (;;) Line 3850  for (;;)
3850            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3851              {              {
3852              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3853              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3854              }              }
3855            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
3856              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3857            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3858            }            }
3859          break;          break;
# Line 3508  for (;;) Line 3864  for (;;)
3864            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3865              {              {
3866              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3867              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3868              }              }
3869            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
3870              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3871            /* 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 */
3872            }            }
3873          break;          break;
# Line 3519  for (;;) Line 3875  for (;;)
3875          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
3876          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3877            {            {
3878            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject)
3879               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))              {
3880              RRETURN(MATCH_NOMATCH);              SCHECK_PARTIAL();
3881                MRRETURN(MATCH_NOMATCH);
3882                }
3883              if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
3884                MRRETURN(MATCH_NOMATCH);
3885            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3886            }            }
3887          break;          break;
# Line 3532  for (;;) Line 3892  for (;;)
3892            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3893              {              {
3894              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3895              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3896              }              }
3897            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
3898              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3899            /* 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 */
3900            }            }
3901          break;          break;
# Line 3558  for (;;) Line 3918  for (;;)
3918            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3919              {              {
3920              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3921              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3922              }              }
3923            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);
3924            eptr++;            eptr++;
3925            }            }
3926          break;          break;
# Line 3569  for (;;) Line 3929  for (;;)
3929          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3930            {            {
3931            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3932            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3933            }            }
3934          eptr += min;          eptr += min;
3935          break;          break;
# Line 3578  for (;;) Line 3938  for (;;)
3938          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
3939            {            {
3940            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3941            RRETURN(MATCH_NOMATCH);            MRRETURN(MATCH_NOMATCH);
3942            }            }
3943          eptr += min;          eptr += min;
3944          break;          break;
# Line 3589  for (;;) Line 3949  for (;;)
3949            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3950              {              {
3951              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3952              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3953              }              }
3954            switch(*eptr++)            switch(*eptr++)
3955              {              {
3956              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
3957              case 0x000d:              case 0x000d:
3958              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3959              break;              break;
# Line 3603  for (;;) Line 3963  for (;;)
3963              case 0x000b:              case 0x000b:
3964              case 0x000c:              case 0x000c:
3965              case 0x0085:              case 0x0085:
3966              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
3967              break;              break;
3968              }              }
3969            }            }
# Line 3615  for (;;) Line 3975  for (;;)
3975            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3976              {              {
3977              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3978              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3979              }              }
3980            switch(*eptr++)            switch(*eptr++)
3981              {              {
# Line 3623  for (;;) Line 3983  for (;;)
3983              case 0x09:      /* HT */              case 0x09:      /* HT */
3984              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
3985              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
3986              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3987              }              }
3988            }            }
3989          break;          break;
# Line 3634  for (;;) Line 3994  for (;;)
3994            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3995              {              {
3996              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3997              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
3998              }              }
3999            switch(*eptr++)            switch(*eptr++)
4000              {              {
4001              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4002              case 0x09:      /* HT */              case 0x09:      /* HT */
4003              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4004              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 3653  for (;;) Line 4013  for (;;)
4013            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4014              {              {
4015              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4016              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4017              }              }
4018            switch(*eptr++)            switch(*eptr++)
4019              {              {
# Line 3663  for (;;) Line 4023  for (;;)
4023              case 0x0c:      /* FF */              case 0x0c:      /* FF */
4024              case 0x0d:      /* CR */              case 0x0d:      /* CR */
4025              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4026              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4027              }              }
4028            }            }
4029          break;          break;
# Line 3674  for (;;) Line 4034  for (;;)
4034            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4035              {              {
4036              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4037              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4038              }              }
4039            switch(*eptr++)            switch(*eptr++)
4040              {              {
4041              default: RRETURN(MATCH_NOMATCH);              default: MRRETURN(MATCH_NOMATCH);
4042              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4043              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4044              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 3695  for (;;) Line 4055  for (;;)
4055            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4056              {              {
4057              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4058              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4059              }              }
4060            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4061            }            }
4062          break;          break;
4063    
# Line 3707  for (;;) Line 4067  for (;;)
4067            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4068              {              {
4069              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4070              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4071              }              }
4072            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4073            }            }
4074          break;          break;
4075    
# Line 3719  for (;;) Line 4079  for (;;)
4079            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4080              {              {
4081              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4082              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4083              }              }
4084            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4085            }            }
4086          break;          break;
4087    
# Line 3731  for (;;) Line 4091  for (;;)
4091            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4092              {              {
4093              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4094              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4095              }              }
4096            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4097            }            }
4098          break;          break;
4099    
# Line 3743  for (;;) Line 4103  for (;;)
4103            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4104              {              {
4105              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4106              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4107              }              }
4108            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4109              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4110            }            }
4111          break;          break;
4112    
# Line 3756  for (;;) Line 4116  for (;;)
4116            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4117              {              {
4118              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4119              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4120              }              }
4121            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4122              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4123            }            }
4124          break;          break;
4125    
# Line 3788  for (;;) Line 4148  for (;;)
4148              {              {
4149              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36);
4150              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4151              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4152              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4153                {                {
4154                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4155                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4156                }                }
4157              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4158              if (prop_fail_result) RRETURN(MATCH_NOMATCH);              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);
4159              }              }
4160            /* Control never gets here */            /* Control never gets here */
4161    
# Line 3804  for (;;) Line 4164  for (;;)
4164              {              {
4165              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37);
4166              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4167              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4168              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4169                {                {
4170                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4171                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4172                }                }
4173              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4174              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4175              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
4176                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
4177                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
4178                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4179              }              }
4180            /* Control never gets here */            /* Control never gets here */
4181    
# Line 3824  for (;;) Line 4184  for (;;)
4184              {              {
4185              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38);
4186              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4187              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4188              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4189                {                {
4190                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4191                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4192                }                }
4193              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4194              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4195              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
4196                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4197              }              }
4198            /* Control never gets here */            /* Control never gets here */
4199    
# Line 3842  for (;;) Line 4202  for (;;)
4202              {              {
4203              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4204              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4205              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4206              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4207                {                {
4208                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4209                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4210                }                }
4211              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4212              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4213              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
4214                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4215              }              }
4216            /* Control never gets here */            /* Control never gets here */
4217    
# Line 3860  for (;;) Line 4220  for (;;)
4220              {              {
4221              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40);
4222              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4223              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) MRRETURN(MATCH_NOMATCH);
4224              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4225                {                {
4226                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4227                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4228                }                }
4229              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
4230              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4231              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
4232                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4233              }              }
4234            /* Control never gets here */            /* Control never gets here */
4235    
4236              case PT_ALNUM:
4237              for (fi = min;; fi++)
4238                {
4239                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4240                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4241                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4242                if (eptr >= md->end_subject)
4243                  {
4244                  SCHECK_PARTIAL();
4245                  MRRETURN(MATCH_NOMATCH);
4246                  }
4247                GETCHARINC(c, eptr);
4248                prop_category = UCD_CATEGORY(c);
4249                if ((prop_category == ucp_L || prop_category == ucp_N)
4250                       == prop_fail_result)
4251                  MRRETURN(MATCH_NOMATCH);
4252                }
4253              /* Control never gets here */
4254    
4255              case PT_SPACE:    /* Perl space */
4256              for (fi = min;; fi++)
4257                {
4258                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4259                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4260                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4261                if (eptr >= md->end_subject)
4262                  {
4263                  SCHECK_PARTIAL();
4264                  MRRETURN(MATCH_NOMATCH);
4265                  }
4266                GETCHARINC(c, eptr);
4267                prop_category = UCD_CATEGORY(c);
4268                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4269                     c == CHAR_FF || c == CHAR_CR)
4270                       == prop_fail_result)
4271                  MRRETURN(MATCH_NOMATCH);
4272                }
4273              /* Control never gets here */
4274    
4275              case PT_PXSPACE:  /* POSIX space */
4276              for (fi = min;; fi++)
4277                {
4278                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4279                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4280                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4281                if (eptr >= md->end_subject)
4282                  {
4283                  SCHECK_PARTIAL();
4284                  MRRETURN(MATCH_NOMATCH);
4285                  }
4286                GETCHARINC(c, eptr);
4287                prop_category = UCD_CATEGORY(c);
4288                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4289                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4290                       == prop_fail_result)
4291                  MRRETURN(MATCH_NOMATCH);
4292                }
4293              /* Control never gets here */
4294    
4295              case PT_WORD:
4296              for (fi = min;; fi++)
4297                {
4298                RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39);
4299                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4300                if (fi >= max) MRRETURN(MATCH_NOMATCH);
4301                if (eptr >= md->end_subject)
4302                  {
4303                  SCHECK_PARTIAL();
4304                  MRRETURN(MATCH_NOMATCH);
4305                  }
4306                GETCHARINC(c, eptr);
4307                prop_category = UCD_CATEGORY(c);
4308                if ((prop_category == ucp_L ||
4309                     prop_category == ucp_N ||
4310                     c == CHAR_UNDERSCORE)
4311                       == prop_fail_result)
4312                  MRRETURN(MATCH_NOMATCH);
4313                }
4314              /* Control never gets here */
4315    
4316              /* This should never occur */
4317    
4318            default:            default:
4319            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4320            }            }
# Line 3887  for (;;) Line 4329  for (;;)
4329            {            {
4330            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41);
4331            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4332            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4333            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4334              {              {
4335              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4336              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4337              }              }
4338            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4339            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4340            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH);
4341            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4342              {              {
4343              int len = 1;              int len = 1;
# Line 3919  for (;;) Line 4361  for (;;)
4361            {            {
4362            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
4363            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4364            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4365            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4366              {              {
4367              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4368              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4369              }              }
4370            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4371              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4372            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4373            switch(ctype)            switch(ctype)
4374              {              {
# Line 3938  for (;;) Line 4380  for (;;)
4380              case OP_ANYNL:              case OP_ANYNL:
4381              switch(c)              switch(c)
4382                {                {
4383                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4384                case 0x000d:                case 0x000d:
4385                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4386                break;                break;
# Line 3950  for (;;) Line 4392  for (;;)
4392                case 0x0085:                case 0x0085:
4393                case 0x2028:                case 0x2028:
4394                case 0x2029:                case 0x2029:
4395                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4396                break;                break;
4397                }                }
4398              break;              break;
# Line 3978  for (;;) Line 4420  for (;;)
4420                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4421                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4422                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4423                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4424                }                }
4425              break;              break;
4426    
4427              case OP_HSPACE:              case OP_HSPACE:
4428              switch(c)              switch(c)
4429                {                {
4430                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4431                case 0x09:      /* HT */                case 0x09:      /* HT */
4432                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4433                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4020  for (;;) Line 4462  for (;;)
4462                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4463                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4464                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4465                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4466                }                }
4467              break;              break;
4468    
4469              case OP_VSPACE:              case OP_VSPACE:
4470              switch(c)              switch(c)
4471                {                {
4472                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4473                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4474                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4475                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4041  for (;;) Line 4483  for (;;)
4483    
4484              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4485              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4486                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4487              break;              break;
4488    
4489              case OP_DIGIT:              case OP_DIGIT:
4490              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4491                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4492              break;              break;
4493    
4494              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4495              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4496                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4497              break;              break;
4498    
4499              case OP_WHITESPACE:              case OP_WHITESPACE:
4500              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4501                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4502              break;              break;
4503    
4504              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4505              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4506                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4507              break;              break;
4508    
4509              case OP_WORDCHAR:              case OP_WORDCHAR:
4510              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4511                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4512              break;              break;
4513    
4514              default:              default:
# Line 4082  for (;;) Line 4524  for (;;)
4524            {            {
4525            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
4526            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4527            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) MRRETURN(MATCH_NOMATCH);
4528            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4529              {              {
4530              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4531              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4532              }              }
4533            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4534              RRETURN(MATCH_NOMATCH);              MRRETURN(MATCH_NOMATCH);
4535            c = *eptr++;            c = *eptr++;
4536            switch(ctype)            switch(ctype)
4537              {              {
# Line 4101  for (;;) Line 4543  for (;;)
4543              case OP_ANYNL:              case OP_ANYNL:
4544              switch(c)              switch(c)
4545                {                {
4546                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4547                case 0x000d:                case 0x000d:
4548                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4549                break;                break;
# Line 4112  for (;;) Line 4554  for (;;)
4554                case 0x000b:                case 0x000b:
4555                case 0x000c:                case 0x000c:
4556                case 0x0085:                case 0x0085:
4557                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);
4558                break;                break;
4559                }                }
4560              break;              break;
# Line 4124  for (;;) Line 4566  for (;;)
4566                case 0x09:      /* HT */                case 0x09:      /* HT */
4567                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4568                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4569                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4570                }                }
4571              break;              break;
4572    
4573              case OP_HSPACE:              case OP_HSPACE:
4574              switch(c)              switch(c)
4575                {                {
4576                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4577                case 0x09:      /* HT */                case 0x09:      /* HT */
4578                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4579                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4148  for (;;) Line 4590  for (;;)
4590                case 0x0c:      /* FF */                case 0x0c:      /* FF */
4591                case 0x0d:      /* CR */                case 0x0d:      /* CR */
4592                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4593                RRETURN(MATCH_NOMATCH);                MRRETURN(MATCH_NOMATCH);
4594                }                }
4595              break;              break;
4596    
4597              case OP_VSPACE:              case OP_VSPACE:
4598              switch(c)              switch(c)
4599                {                {
4600                default: RRETURN(MATCH_NOMATCH);                default: MRRETURN(MATCH_NOMATCH);
4601                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4602                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4603                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4166  for (;;) Line 4608  for (;;)
4608              break;              break;
4609    
4610              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4611              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);
4612              break;              break;
4613    
4614              case OP_DIGIT:              case OP_DIGIT:
4615              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);
4616              break;              break;
4617    
4618              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4619              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);
4620              break;              break;
4621    
4622              case OP_WHITESPACE:              case OP_WHITESPACE:
4623              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);
4624              break;              break;
4625    
4626              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4627              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);
4628              break;              break;
4629    
4630              case OP_WORDCHAR:              case OP_WORDCHAR:
4631              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);
4632              break;              break;
4633    
4634              default:              default:
# Line 4214  for (;;) Line 4656  for (;;)
4656            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4657              {              {
4658              int len = 1;              int len = 1;
4659              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4660                  {
4661                  SCHECK_PARTIAL();
4662                  break;
4663                  }
4664              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4665              if (prop_fail_result) break;              if (prop_fail_result) break;
4666              eptr+= len;              eptr+= len;
# Line 4225  for (;;) Line 4671  for (;;)
4671            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4672              {              {
4673              int len = 1;              int len = 1;
4674              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4675                  {
4676                  SCHECK_PARTIAL();
4677                  break;
4678                  }
4679              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4680              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4681              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
# Line 4240  for (;;) Line 4690  for (;;)
4690            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4691              {              {
4692              int len = 1;              int len = 1;
4693              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4694                  {
4695                  SCHECK_PARTIAL();
4696                  break;
4697                  }
4698              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4699              prop_category = UCD_CATEGORY(c);              prop_category = UCD_CATEGORY(c);
4700              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
# Line 4253  for (;;) Line 4707  for (;;)
4707            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4708              {              {
4709              int len = 1;              int len = 1;
4710              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4711                  {
4712                  SCHECK_PARTIAL();
4713                  break;
4714                  }
4715              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4716              prop_chartype = UCD_CHARTYPE(c);              prop_chartype = UCD_CHARTYPE(c);
4717              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
# Line 4266  for (;;) Line 4724  for (;;)
4724            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4725              {              {
4726              int len = 1;              int len = 1;
4727              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4728                  {
4729                  SCHECK_PARTIAL();
4730                  break;
4731                  }
4732              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4733              prop_script = UCD_SCRIPT(c);              prop_script = UCD_SCRIPT(c);
4734              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
# Line 4274  for (;;) Line 4736  for (;;)
4736              eptr+= len;              eptr+= len;
4737              }              }
4738            break;            break;
4739    
4740              case PT_ALNUM:
4741              for (i = min; i < max; i++)
4742                {
4743                int len = 1;
4744                if (eptr >= md->end_subject)
4745                  {
4746                  SCHECK_PARTIAL();
4747                  break;
4748                  }
4749                GETCHARLEN(c, eptr, len);
4750                prop_category = UCD_CATEGORY(c);
4751                if ((prop_category == ucp_L || prop_category == ucp_N)
4752                     == prop_fail_result)
4753                  break;
4754                eptr+= len;
4755                }
4756              break;
4757    
4758              case PT_SPACE:    /* Perl space */
4759              for (i = min; i < max; i++)
4760                {
4761                int len = 1;
4762                if (eptr >= md->end_subject)
4763                  {
4764                  SCHECK_PARTIAL();
4765                  break;
4766                  }
4767                GETCHARLEN(c, eptr, len);
4768                prop_category = UCD_CATEGORY(c);
4769                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4770                     c == CHAR_FF || c == CHAR_CR)
4771                     == prop_fail_result)
4772                  break;
4773                eptr+= len;
4774                }
4775              break;
4776    
4777              case PT_PXSPACE:  /* POSIX space */
4778              for (i = min; i < max; i++)
4779                {
4780                int len = 1;
4781                if (eptr >= md->end_subject)
4782                  {
4783                  SCHECK_PARTIAL();
4784                  break;
4785                  }
4786                GETCHARLEN(c, eptr, len);
4787                prop_category = UCD_CATEGORY(c);
4788                if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4789                     c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4790                     == prop_fail_result)
4791                  break;
4792                eptr+= len;
4793                }
4794              break;
4795    
4796              case PT_WORD:
4797              for (i = min; i < max; i++)
4798                {
4799                int len = 1;
4800                if (eptr >= md->end_subject)
4801                  {
4802                  SCHECK_PARTIAL();
4803                  break;
4804                  }
4805                GETCHARLEN(c, eptr, len);
4806                prop_category = UCD_CATEGORY(c);
4807                if ((prop_category == ucp_L || prop_category == ucp_N ||
4808                     c == CHAR_UNDERSCORE) == prop_fail_result)
4809                  break;
4810                eptr+= len;
4811                }
4812              break;
4813    
4814              default:
4815              RRETURN(PCRE_ERROR_INTERNAL);
4816            }            }
4817    
4818          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 4295  for (;;) Line 4834  for (;;)
4834          {          {
4835          for (i = min; i < max; i++)          for (i = min; i < max; i++)
4836            {            {
4837            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject)
4838                {
4839                SCHECK_PARTIAL();
4840                break;
4841                }
4842            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4843            prop_category = UCD_CATEGORY(c);            prop_category = UCD_CATEGORY(c);
4844            if (prop_category == ucp_M) break;            if (prop_category == ucp_M) break;
# Line 4315  for (;;) Line 4858  for (;;)
4858          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
4859    
4860          if (possessive) continue;          if (possessive) continue;
4861    
4862          for(;;)          for(;;)
4863            {            {
4864            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45);
# Line 4350  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 || IS_NEWLINE(eptr)) break;                if (eptr >= md->end_subject)
4898                    {
4899                    SCHECK_PARTIAL();
4900                    break;
4901                    }
4902                  if (IS_NEWLINE(eptr)) break;
4903                eptr++;                eptr++;
4904                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4905                }                }
# Line 4362  for (;;) Line 4911  for (;;)
4911              {              {
4912              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4913                {                {
4914                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                if (eptr >= md->end_subject)
4915                    {
4916                    SCHECK_PARTIAL();
4917                    break;
4918                    }
4919                  if (IS_NEWLINE(eptr)) break;
4920                eptr++;                eptr++;
4921                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4922                }                }
# Line 4374  for (;;) Line 4928  for (;;)
4928              {              {
4929              for (i = min; i < max; i++)              for (i = min; i < max; i++)
4930                {                {
4931                if (eptr >= md->end_subject) break;                if (eptr >= md->end_subject)
4932                    {
4933                    SCHECK_PARTIAL();
4934                    break;
4935                    }
4936                eptr++;                eptr++;
4937                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4938                }                }
# Line 4387  for (;;) Line 4945  for (;;)
4945            case OP_ANYBYTE:            case OP_ANYBYTE:
4946            c = max - min;            c = max - min;
4947            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
4948              c = md->end_subject - eptr;              {
4949            eptr += c;              eptr = md->end_subject;
4950                SCHECK_PARTIAL();
4951                }
4952              else eptr += c;
4953            break;            break;
4954    
4955            case OP_ANYNL:            case OP_ANYNL:
4956            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4957              {              {
4958              int len = 1;              int len = 1;
4959              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4960                  {
4961                  SCHECK_PARTIAL();
4962                  break;
4963                  }
4964              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4965              if (c == 0x000d)              if (c == 0x000d)
4966                {                {
# Line 4420  for (;;) Line 4985  for (;;)
4985              {              {
4986              BOOL gotspace;              BOOL gotspace;
4987              int len = 1;              int len = 1;
4988              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
4989                  {
4990                  SCHECK_PARTIAL();
4991                  break;
4992                  }
4993              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
4994              switch(c)              switch(c)
4995                {                {
# Line 4458  for (;;) Line 5027  for (;;)
5027              {              {
5028              BOOL gotspace;              BOOL gotspace;
5029              int len = 1;              int len = 1;
5030              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5031                  {
5032                  SCHECK_PARTIAL();
5033                  break;
5034                  }
5035              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5036              switch(c)              switch(c)
5037                {                {
# Line 4482  for (;;) Line 5055  for (;;)
5055            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5056              {              {
5057              int len = 1;              int len = 1;
5058              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5059                  {
5060                  SCHECK_PARTIAL();
5061                  break;
5062                  }
5063              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5064              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
5065              eptr+= len;              eptr+= len;
# Line 4493  for (;;) Line 5070  for (;;)
5070            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5071              {              {
5072              int len = 1;              int len = 1;
5073              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5074                  {
5075                  SCHECK_PARTIAL();
5076                  break;
5077                  }
5078              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5079              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;              if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
5080              eptr+= len;              eptr+= len;
# Line 4504  for (;;) Line 5085  for (;;)
5085            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5086              {              {
5087              int len = 1;              int len = 1;
5088              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5089                  {
5090                  SCHECK_PARTIAL();
5091                  break;
5092                  }
5093              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5094              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
5095              eptr+= len;              eptr+= len;
# Line 4515  for (;;) Line 5100  for (;;)
5100            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5101              {              {
5102              int len = 1;              int len = 1;
5103              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5104                  {
5105                  SCHECK_PARTIAL();
5106                  break;
5107                  }
5108              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5109              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;              if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
5110              eptr+= len;              eptr+= len;
# Line 4526  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_word) != 0) break;              if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
5125              eptr+= len;              eptr+= len;
# Line 4537  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_word) == 0) break;              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
5140              eptr+= len;              eptr+= len;
# Line 4569  for (;;) Line 5166  for (;;)
5166            case OP_ANY:            case OP_ANY:
5167            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5168              {              {
5169              if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;              if (eptr >= md->end_subject)
5170                  {
5171                  SCHECK_PARTIAL();
5172                  break;
5173                  }
5174                if (IS_NEWLINE(eptr)) break;
5175              eptr++;              eptr++;
5176              }              }
5177            break;            break;
# Line 4578  for (;;) Line 5180  for (;;)
5180            case OP_ANYBYTE:            case OP_ANYBYTE:
5181            c = max - min;            c = max - min;
5182            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
5183              c = md->end_subject - eptr;              {
5184            eptr += c;              eptr = md->end_subject;
5185                SCHECK_PARTIAL();
5186                }
5187              else eptr += c;
5188            break;            break;
5189    
5190            case OP_ANYNL:            case OP_ANYNL:
5191            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5192              {              {
5193              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5194                  {
5195                  SCHECK_PARTIAL();
5196                  break;
5197                  }
5198              c = *eptr;              c = *eptr;
5199              if (c == 0x000d)              if (c == 0x000d)
5200                {                {
# Line 4606  for (;;) Line 5215  for (;;)
5215            case OP_NOT_HSPACE:            case OP_NOT_HSPACE:
5216            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5217              {              {
5218              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5219                  {
5220                  SCHECK_PARTIAL();
5221                  break;
5222                  }
5223              c = *eptr;              c = *eptr;
5224              if (c == 0x09 || c == 0x20 || c == 0xa0) break;              if (c == 0x09 || c == 0x20 || c == 0xa0) break;
5225              eptr++;              eptr++;
# Line 4616  for (;;) Line 5229  for (;;)
5229            case OP_HSPACE:            case OP_HSPACE:
5230            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5231              {              {
5232              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5233                  {
5234                  SCHECK_PARTIAL();
5235                  break;
5236                  }
5237              c = *eptr;              c = *eptr;
5238              if (c != 0x09 && c != 0x20 && c != 0xa0) break;              if (c != 0x09 && c != 0x20 && c != 0xa0) break;
5239              eptr++;              eptr++;
# Line 4626  for (;;) Line 5243  for (;;)
5243            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
5244            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5245              {              {
5246              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5247                  {
5248                  SCHECK_PARTIAL();
5249                  break;
5250                  }
5251              c = *eptr;              c = *eptr;
5252              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
5253                break;                break;
# Line 4637  for (;;) Line 5258  for (;;)
5258            case OP_VSPACE:            case OP_VSPACE:
5259            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5260              {              {
5261              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject)
5262                  {
5263                  SCHECK_PARTIAL();
5264                  break;
5265                  }
5266              c = *eptr;              c = *eptr;
5267              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
5268                break;                break;
# Line 4648  for (;;) Line 5273  for (;;)
5273            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
5274            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5275              {              {
5276              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) != 0)              if (eptr >= md->end_subject)
5277                  {
5278                  SCHECK_PARTIAL();
5279                break;                break;
5280                  }
5281                if ((md->ctypes[*eptr] & ctype_digit) != 0) break;
5282              eptr++;              eptr++;
5283              }              }
5284            break;            break;
# Line 4657  for (;;) Line 5286  for (;;)
5286            case OP_DIGIT:            case OP_DIGIT:
5287            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5288              {              {
5289              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) == 0)              if (eptr >= md->end_subject)
5290                  {
5291                  SCHECK_PARTIAL();
5292                break;                break;
5293                  }
5294                if ((md->ctypes[*eptr] & ctype_digit) == 0) break;
5295              eptr++;              eptr++;
5296              }              }
5297            break;            break;
# Line 4666  for (;;) Line 5299  for (;;)
5299            case OP_NOT_WHITESPACE:            case OP_NOT_WHITESPACE:
5300            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5301              {              {
5302              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) != 0)              if (eptr >= md->end_subject)
5303                  {
5304                  SCHECK_PARTIAL();
5305                break;                break;
5306                  }
5307                if ((md->ctypes[*eptr] & ctype_space) != 0) break;
5308              eptr++;              eptr++;
5309              }              }
5310            break;            break;
# Line 4675  for (;;) Line 5312  for (;;)
5312            case OP_WHITESPACE:            case OP_WHITESPACE:
5313            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5314              {              {
5315              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) == 0)              if (eptr >= md->end_subject)
5316                  {
5317                  SCHECK_PARTIAL();
5318                break;                break;
5319                  }
5320                if ((md->ctypes[*eptr] & ctype_space) == 0) break;
5321              eptr++;              eptr++;
5322              }              }
5323            break;            break;
# Line 4684  for (;;) Line 5325  for (;;)
5325            case OP_NOT_WORDCHAR:            case OP_NOT_WORDCHAR:
5326            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5327              {              {
5328              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) != 0)              if (eptr >= md->end_subject)
5329                  {
5330                  SCHECK_PARTIAL();
5331                break;                break;
5332                  }
5333                if ((md->ctypes[*eptr] & ctype_word) != 0) break;
5334              eptr++;              eptr++;
5335              }              }
5336            break;            break;
# Line 4693  for (;;) Line 5338  for (;;)
5338            case OP_WORDCHAR:            case OP_WORDCHAR:
5339            for (i = min; i < max; i++)            for (i = min; i < max; i++)
5340              {              {
5341              if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) == 0)              if (eptr >= md->end_subject)
5342                  {
5343                  SCHECK_PARTIAL();
5344                break;                break;
5345                  }
5346                if ((md->ctypes[*eptr] & ctype_word) == 0) break;
5347              eptr++;              eptr++;
5348              }              }
5349            break;            break;
# Line 4716  for (;;) Line 5365  for (;;)
5365    
5366        /* Get here if we can't make it match with any permitted repetitions */        /* Get here if we can't make it match with any permitted repetitions */
5367    
5368        RRETURN(MATCH_NOMATCH);        MRRETURN(MATCH_NOMATCH);
5369        }        }
5370      /* Control never gets here */      /* Control never gets here */
5371    
# Line 4749  switch (frame->Xwhere) Line 5398  switch (frame->Xwhere)
5398    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
5399    LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)    LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
5400    LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)    LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
5401    LBL(53) LBL(54)    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58)
5402  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
5403    LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)    LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
5404    LBL(32) LBL(34) LBL(42) LBL(46)    LBL(32) LBL(34) LBL(42) LBL(46)
# Line 4889  if (re == NULL || subject == NULL || Line 5538  if (re == NULL || subject == NULL ||
5538     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
5539  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
5540    
5541    /* This information is for finding all the numbers associated with a given
5542    name, for condition testing. */
5543    
5544    md->name_table = (uschar *)re + re->name_table_offset;
5545    md->name_count = re->name_count;
5546    md->name_entry_size = re->name_entry_size;
5547    
5548  /* Fish out the optional data from the extra_data structure, first setting  /* Fish out the optional data from the extra_data structure, first setting
5549  the default values. */  the default values. */
5550    
# Line 4960  md->notempty_atstart = (options & PCRE_N Line 5616  md->notempty_atstart = (options & PCRE_N
5616  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :  md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5617                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;                ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5618  md->hitend = FALSE;  md->hitend = FALSE;
5619    md->mark = NULL;                        /* In case never set */
5620    
5621  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
5622    
# Line 5247  for(;;) Line 5904  for(;;)
5904    /* Restore fudged end_subject */    /* Restore fudged end_subject */
5905    
5906    end_subject = save_end_subject;    end_subject = save_end_subject;
5907    
5908    /* The following two optimizations are disabled for partial matching or if    /* The following two optimizations are disabled for partial matching or if
5909    disabling is explicitly requested. */    disabling is explicitly requested. */
5910    
5911    if ((options & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)    if ((options & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)
5912      {      {
5913      /* If the pattern was studied, a minimum subject length may be set. This is      /* If the pattern was studied, a minimum subject length may be set. This is
5914      a lower bound; no actual string of that length may actually match the      a lower bound; no actual string of that length may actually match the
5915      pattern. Although the value is, strictly, in characters, we treat it as      pattern. Although the value is, strictly, in characters, we treat it as
5916      bytes to avoid spending too much time in this optimization. */      bytes to avoid spending too much time in this optimization. */
5917    
5918      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
5919          end_subject - start_match < study->minlength)          (pcre_uint32)(end_subject - start_match) < study->minlength)
5920        {        {
5921        rc = MATCH_NOMATCH;        rc = MATCH_NOMATCH;
5922        break;        break;
5923        }        }
5924    
5925      /* If req_byte is set, we know that that character must appear in the      /* If req_byte is set, we know that that character must appear in the
5926      subject for the match to succeed. If the first character is set, req_byte      subject for the match to succeed. If the first character is set, req_byte
5927      must be later in the subject; otherwise the test starts at the match point.      must be later in the subject; otherwise the test starts at the match point.
# Line 5272  for(;;) Line 5929  for(;;)
5929      nested unlimited repeats that aren't going to match. Writing separate code      nested unlimited repeats that aren't going to match. Writing separate code
5930      for cased/caseless versions makes it go faster, as does using an      for cased/caseless versions makes it go faster, as does using an
5931      autoincrement and backing off on a match.      autoincrement and backing off on a match.
5932    
5933      HOWEVER: when the subject string is very, very long, searching to its end      HOWEVER: when the subject string is very, very long, searching to its end
5934      can take a long time, and give bad performance on quite ordinary patterns.      can take a long time, and give bad performance on quite ordinary patterns.
5935      This showed up when somebody was matching something like /^\d+C/ on a      This showed up when somebody was matching something like /^\d+C/ on a
5936      32-megabyte string... so we don't do this when the string is sufficiently      32-megabyte string... so we don't do this when the string is sufficiently
5937      long. */      long. */
5938    
5939      if (req_byte >= 0 && end_subject - start_match < REQ_BYTE_MAX)      if (req_byte >= 0 && end_subject - start_match < REQ_BYTE_MAX)
5940        {        {
5941        register USPTR p = start_match + ((first_byte >= 0)? 1 : 0);        register USPTR p = start_match + ((first_byte >= 0)? 1 : 0);
5942    
5943        /* We don't need to repeat the search if we haven't yet reached the        /* We don't need to repeat the search if we haven't yet reached the
5944        place we found it at last time. */        place we found it at last time. */
5945    
5946        if (p > req_byte_ptr)        if (p > req_byte_ptr)
5947          {          {
5948          if (req_byte_caseless)          if (req_byte_caseless)
# Line 5303  for(;;) Line 5960  for(;;)
5960              if (*p++ == req_byte) { p--; break; }              if (*p++ == req_byte) { p--; break; }
5961              }              }
5962            }            }
5963    
5964          /* If we can't find the required character, break the matching loop,          /* If we can't find the required character, break the matching loop,
5965          forcing a match failure. */          forcing a match failure. */
5966    
5967          if (p >= end_subject)          if (p >= end_subject)
5968            {            {
5969            rc = MATCH_NOMATCH;            rc = MATCH_NOMATCH;
5970            break;            break;
5971            }            }
5972    
5973          /* If we have found the required character, save the point where we          /* If we have found the required character, save the point where we
5974          found it, so that we don't search again next time round the loop if          found it, so that we don't search again next time round the loop if
5975          the start hasn't passed this character yet. */          the start hasn't passed this character yet. */
5976    
5977          req_byte_ptr = p;          req_byte_ptr = p;
5978          }          }
5979        }        }
5980      }      }
5981    
5982  #ifdef DEBUG  /* Sigh. Some compilers never learn. */  #ifdef PCRE_DEBUG  /* Sigh. Some compilers never learn. */
5983    printf(">>>> Match against: ");    printf(">>>> Match against: ");
5984    pchars(start_match, end_subject - start_match, TRUE, md);    pchars(start_match, end_subject - start_match, TRUE, md);
5985    printf("\n");    printf("\n");
# Line 5334  for(;;) Line 5991  for(;;)
5991    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
5992    md->start_used_ptr = start_match;    md->start_used_ptr = start_match;
5993    md->match_call_count = 0;    md->match_call_count = 0;
5994    rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);    rc = match(start_match, md->start_code, start_match, NULL, 2, md, ims, NULL,
5995        0, 0);
5996    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
5997    
5998    switch(rc)    switch(rc)
5999      {      {
6000      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. If MATCH_SKIP_ARG reaches
6001      exactly like PRUNE. */      this level it means that a MARK that matched the SKIP's arg was not found.
6002        We treat this as NOMATCH. THEN at this level acts exactly like PRUNE. */
6003    
6004      case MATCH_NOMATCH:      case MATCH_NOMATCH:
6005      case MATCH_PRUNE:      case MATCH_PRUNE:
6006        case MATCH_SKIP_ARG:
6007      case MATCH_THEN:      case MATCH_THEN:
6008      new_start_match = start_match + 1;      new_start_match = start_match + 1;
6009  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
# Line 5404  for(;;) Line 6064  for(;;)
6064           md->nllen == 2))           md->nllen == 2))
6065      start_match++;      start_match++;
6066    
6067    }   /* End of for(;;) "bumpalong" loop */    md->mark = NULL;   /* Reset for start of next match attempt */
6068      }                  /* End of for(;;) "bumpalong" loop */
6069    
6070  /* ==========================================================================*/  /* ==========================================================================*/
6071    
# Line 5428  capturing parentheses than vector slots. Line 6089  capturing parentheses than vector slots.
6089    
6090  ENDLOOP:  ENDLOOP:
6091    
6092  if (rc == MATCH_MATCH)  if (rc == MATCH_MATCH || rc == MATCH_ACCEPT)
6093    {    {
6094    if (using_temporary_offsets)    if (using_temporary_offsets)
6095      {      {
# Line 5447  if (rc == MATCH_MATCH) Line 6108  if (rc == MATCH_MATCH)
6108    too many to fit into the vector. */    too many to fit into the vector. */
6109    
6110    rc = md->offset_overflow? 0 : md->end_offset_top/2;    rc = md->offset_overflow? 0 : md->end_offset_top/2;
6111    
6112    /* If there is space, set up the whole thing as substring 0. The value of    /* If there is space, set up the whole thing as substring 0. The value of
6113    md->start_match_ptr might be modified if \K was encountered on the success    md->start_match_ptr might be modified if \K was encountered on the success