/[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 648 by ph10, Mon Aug 1 11:02:08 2011 UTC revision 771 by ph10, Tue Nov 29 15:34:12 2011 UTC
# Line 82  negative to avoid the external error cod Line 82  negative to avoid the external error cod
82  #define MATCH_SKIP_ARG     (-993)  #define MATCH_SKIP_ARG     (-993)
83  #define MATCH_THEN         (-992)  #define MATCH_THEN         (-992)
84    
 /* This is a convenience macro for code that occurs many times. */  
   
 #define MRRETURN(ra) \  
   { \  
   md->mark = markptr; \  
   RRETURN(ra); \  
   }  
   
85  /* 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.
86  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,
87  because the offset vector is always a multiple of 3 long. */  because the offset vector is always a multiple of 3 long. */
# Line 277  enum { RM1=1, RM2, RM3, RM4, RM5, RM Line 269  enum { RM1=1, RM2, RM3, RM4, RM5, RM
269         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
270         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
271         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
272         RM61,  RM62, RM63 };         RM61,  RM62, RM63, RM64, RM65, RM66 };
273    
274  /* 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
275  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
# Line 290  actually used in this definition. */ Line 282  actually used in this definition. */
282  #define RMATCH(ra,rb,rc,rd,re,rw) \  #define RMATCH(ra,rb,rc,rd,re,rw) \
283    { \    { \
284    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
285    rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1); \    rrc = match(ra,rb,mstart,rc,rd,re,rdepth+1); \
286    printf("to line %d\n", __LINE__); \    printf("to line %d\n", __LINE__); \
287    }    }
288  #define RRETURN(ra) \  #define RRETURN(ra) \
# Line 300  actually used in this definition. */ Line 292  actually used in this definition. */
292    }    }
293  #else  #else
294  #define RMATCH(ra,rb,rc,rd,re,rw) \  #define RMATCH(ra,rb,rc,rd,re,rw) \
295    rrc = match(ra,rb,mstart,markptr,rc,rd,re,rdepth+1)    rrc = match(ra,rb,mstart,rc,rd,re,rdepth+1)
296  #define RRETURN(ra) return ra  #define RRETURN(ra) return ra
297  #endif  #endif
298    
# Line 321  argument of match(), which never changes Line 313  argument of match(), which never changes
313    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
314    newframe->Xecode = rb;\    newframe->Xecode = rb;\
315    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
   newframe->Xmarkptr = markptr;\  
316    newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
317    newframe->Xeptrb = re;\    newframe->Xeptrb = re;\
318    newframe->Xrdepth = frame->Xrdepth + 1;\    newframe->Xrdepth = frame->Xrdepth + 1;\
# Line 357  typedef struct heapframe { Line 348  typedef struct heapframe {
348    USPTR Xeptr;    USPTR Xeptr;
349    const uschar *Xecode;    const uschar *Xecode;
350    USPTR Xmstart;    USPTR Xmstart;
   USPTR Xmarkptr;  
351    int Xoffset_top;    int Xoffset_top;
352    eptrblock *Xeptrb;    eptrblock *Xeptrb;
353    unsigned int Xrdepth;    unsigned int Xrdepth;
# Line 438  the subject. */ Line 428  the subject. */
428        eptr > md->start_used_ptr) \        eptr > md->start_used_ptr) \
429      { \      { \
430      md->hitend = TRUE; \      md->hitend = TRUE; \
431      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
432      }      }
433    
434  #define SCHECK_PARTIAL()\  #define SCHECK_PARTIAL()\
435    if (md->partial != 0 && eptr > md->start_used_ptr) \    if (md->partial != 0 && eptr > md->start_used_ptr) \
436      { \      { \
437      md->hitend = TRUE; \      md->hitend = TRUE; \
438      if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL); \      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
439      }      }
440    
441    
# Line 459  Arguments: Line 449  Arguments:
449     ecode       pointer to current position in compiled code     ecode       pointer to current position in compiled code
450     mstart      pointer to the current match start position (can be modified     mstart      pointer to the current match start position (can be modified
451                   by encountering \K)                   by encountering \K)
    markptr     pointer to the most recent MARK name, or NULL  
452     offset_top  current top pointer     offset_top  current top pointer
453     md          pointer to "static" info for the match     md          pointer to "static" info for the match
454     eptrb       pointer to chain of blocks containing eptr at start of     eptrb       pointer to chain of blocks containing eptr at start of
# Line 475  Returns: MATCH_MATCH if matched Line 464  Returns: MATCH_MATCH if matched
464    
465  static int  static int
466  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,
467    const uschar *markptr, int offset_top, match_data *md, eptrblock *eptrb,    int offset_top, match_data *md, eptrblock *eptrb, unsigned int rdepth)
   unsigned int rdepth)  
468  {  {
469  /* 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,
470  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 506  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;
 frame->Xmarkptr = markptr;  
497  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
498  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
499  frame->Xrdepth = rdepth;  frame->Xrdepth = rdepth;
# Line 520  HEAP_RECURSE: Line 507  HEAP_RECURSE:
507  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
508  #define ecode              frame->Xecode  #define ecode              frame->Xecode
509  #define mstart             frame->Xmstart  #define mstart             frame->Xmstart
 #define markptr            frame->Xmarkptr  
510  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
511  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
512  #define rdepth             frame->Xrdepth  #define rdepth             frame->Xrdepth
# Line 701  for (;;) Line 687  for (;;)
687    switch(op)    switch(op)
688      {      {
689      case OP_MARK:      case OP_MARK:
690      markptr = ecode + 2;      md->nomatch_mark = ecode + 2;
691        md->mark = NULL;    /* In case previously set by assertion */
692      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
693        eptrb, RM55);        eptrb, RM55);
694        if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
695             md->mark == NULL) md->mark = ecode + 2;
696    
697      /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an      /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
698      argument, and we must check whether that argument matches this MARK's      argument, and we must check whether that argument matches this MARK's
# Line 712  for (;;) Line 701  for (;;)
701      position and return MATCH_SKIP. Otherwise, pass back the return code      position and return MATCH_SKIP. Otherwise, pass back the return code
702      unaltered. */      unaltered. */
703    
704      if (rrc == MATCH_SKIP_ARG &&      else if (rrc == MATCH_SKIP_ARG &&
705          strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0)          strcmp((char *)(ecode + 2), (char *)(md->start_match_ptr)) == 0)
706        {        {
707        md->start_match_ptr = eptr;        md->start_match_ptr = eptr;
708        RRETURN(MATCH_SKIP);        RRETURN(MATCH_SKIP);
709        }        }
   
     if (md->mark == NULL) md->mark = markptr;  
710      RRETURN(rrc);      RRETURN(rrc);
711    
712      case OP_FAIL:      case OP_FAIL:
713      MRRETURN(MATCH_NOMATCH);      RRETURN(MATCH_NOMATCH);
714    
715      /* COMMIT overrides PRUNE, SKIP, and THEN */      /* COMMIT overrides PRUNE, SKIP, and THEN */
716    
# Line 734  for (;;) Line 721  for (;;)
721          rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&          rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&
722          rrc != MATCH_THEN)          rrc != MATCH_THEN)
723        RRETURN(rrc);        RRETURN(rrc);
724      MRRETURN(MATCH_COMMIT);      RRETURN(MATCH_COMMIT);
725    
726      /* PRUNE overrides THEN */      /* PRUNE overrides THEN */
727    
# Line 742  for (;;) Line 729  for (;;)
729      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
730        eptrb, RM51);        eptrb, RM51);
731      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
732      MRRETURN(MATCH_PRUNE);      RRETURN(MATCH_PRUNE);
733    
734      case OP_PRUNE_ARG:      case OP_PRUNE_ARG:
735        md->nomatch_mark = ecode + 2;
736        md->mark = NULL;    /* In case previously set by assertion */
737      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
738        eptrb, RM56);        eptrb, RM56);
739        if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
740             md->mark == NULL) md->mark = ecode + 2;
741      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
     md->mark = ecode + 2;  
742      RRETURN(MATCH_PRUNE);      RRETURN(MATCH_PRUNE);
743    
744      /* SKIP overrides PRUNE and THEN */      /* SKIP overrides PRUNE and THEN */
# Line 759  for (;;) Line 749  for (;;)
749      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
750        RRETURN(rrc);        RRETURN(rrc);
751      md->start_match_ptr = eptr;   /* Pass back current position */      md->start_match_ptr = eptr;   /* Pass back current position */
752      MRRETURN(MATCH_SKIP);      RRETURN(MATCH_SKIP);
753    
754        /* Note that, for Perl compatibility, SKIP with an argument does NOT set
755        nomatch_mark. There is a flag that disables this opcode when re-matching a
756        pattern that ended with a SKIP for which there was not a matching MARK. */
757    
758      case OP_SKIP_ARG:      case OP_SKIP_ARG:
759        if (md->ignore_skip_arg)
760          {
761          ecode += _pcre_OP_lengths[*ecode] + ecode[1];
762          break;
763          }
764      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,
765        eptrb, RM57);        eptrb, RM57);
766      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
# Line 769  for (;;) Line 768  for (;;)
768    
769      /* Pass back the current skip name by overloading md->start_match_ptr and      /* Pass back the current skip name by overloading md->start_match_ptr and
770      returning the special MATCH_SKIP_ARG return code. This will either be      returning the special MATCH_SKIP_ARG return code. This will either be
771      caught by a matching MARK, or get to the top, where it is treated the same      caught by a matching MARK, or get to the top, where it causes a rematch
772      as PRUNE. */      with the md->ignore_skip_arg flag set. */
773    
774      md->start_match_ptr = ecode + 2;      md->start_match_ptr = ecode + 2;
775      RRETURN(MATCH_SKIP_ARG);      RRETURN(MATCH_SKIP_ARG);
776    
777      /* For THEN (and THEN_ARG) we pass back the address of the bracket or      /* For THEN (and THEN_ARG) we pass back the address of the opcode, so that
778      the alt that is at the start of the current branch. This makes it possible      the branch in which it occurs can be determined. Overload the start of
779      to skip back past alternatives that precede the THEN within the current      match pointer to do this. */
     branch. */  
780    
781      case OP_THEN:      case OP_THEN:
782      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
783        eptrb, RM54);        eptrb, RM54);
784      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
785      md->start_match_ptr = ecode - GET(ecode, 1);      md->start_match_ptr = ecode;
786      MRRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
787    
788      case OP_THEN_ARG:      case OP_THEN_ARG:
789      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1+LINK_SIZE],      md->nomatch_mark = ecode + 2;
790        offset_top, md, eptrb, RM58);      md->mark = NULL;    /* In case previously set by assertion */
791        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top,
792          md, eptrb, RM58);
793        if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
794             md->mark == NULL) md->mark = ecode + 2;
795      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
796      md->start_match_ptr = ecode - GET(ecode, 1);      md->start_match_ptr = ecode;
     md->mark = ecode + LINK_SIZE + 2;  
797      RRETURN(MATCH_THEN);      RRETURN(MATCH_THEN);
798    
799        /* Handle an atomic group that does not contain any capturing parentheses.
800        This can be handled like an assertion. Prior to 8.13, all atomic groups
801        were handled this way. In 8.13, the code was changed as below for ONCE, so
802        that backups pass through the group and thereby reset captured values.
803        However, this uses a lot more stack, so in 8.20, atomic groups that do not
804        contain any captures generate OP_ONCE_NC, which can be handled in the old,
805        less stack intensive way.
806    
807        Check the alternative branches in turn - the matching won't pass the KET
808        for this kind of subpattern. If any one branch matches, we carry on as at
809        the end of a normal bracket, leaving the subject pointer, but resetting
810        the start-of-match value in case it was changed by \K. */
811    
812        case OP_ONCE_NC:
813        prev = ecode;
814        saved_eptr = eptr;
815        do
816          {
817          RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
818          if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
819            {
820            mstart = md->start_match_ptr;
821            break;
822            }
823          if (rrc == MATCH_THEN)
824            {
825            next = ecode + GET(ecode,1);
826            if (md->start_match_ptr < next &&
827                (*ecode == OP_ALT || *next == OP_ALT))
828              rrc = MATCH_NOMATCH;
829            }
830    
831          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
832          ecode += GET(ecode,1);
833          }
834        while (*ecode == OP_ALT);
835    
836        /* If hit the end of the group (which could be repeated), fail */
837    
838        if (*ecode != OP_ONCE_NC && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
839    
840        /* Continue as from after the group, updating the offsets high water
841        mark, since extracts may have been taken. */
842    
843        do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
844    
845        offset_top = md->end_offset_top;
846        eptr = md->end_match_ptr;
847    
848        /* For a non-repeating ket, just continue at this level. This also
849        happens for a repeating ket if no characters were matched in the group.
850        This is the forcible breaking of infinite loops as implemented in Perl
851        5.005. */
852    
853        if (*ecode == OP_KET || eptr == saved_eptr)
854          {
855          ecode += 1+LINK_SIZE;
856          break;
857          }
858    
859        /* The repeating kets try the rest of the pattern or restart from the
860        preceding bracket, in the appropriate order. The second "call" of match()
861        uses tail recursion, to avoid using another stack frame. */
862    
863        if (*ecode == OP_KETRMIN)
864          {
865          RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM65);
866          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
867          ecode = prev;
868          goto TAIL_RECURSE;
869          }
870        else  /* OP_KETRMAX */
871          {
872          md->match_function_type = MATCH_CBEGROUP;
873          RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
874          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
875          ecode += 1 + LINK_SIZE;
876          goto TAIL_RECURSE;
877          }
878        /* Control never gets here */
879    
880      /* Handle a capturing bracket, other than those that are possessive with an      /* Handle a capturing bracket, other than those that are possessive with an
881      unlimited repeat. If there is space in the offset vector, save the current      unlimited repeat. If there is space in the offset vector, save the current
882      subject position in the working slot at the top of the vector. We mustn't      subject position in the working slot at the top of the vector. We mustn't
# Line 838  for (;;) Line 920  for (;;)
920          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
921            eptrb, RM1);            eptrb, RM1);
922          if (rrc == MATCH_ONCE) break;  /* Backing up through an atomic group */          if (rrc == MATCH_ONCE) break;  /* Backing up through an atomic group */
923          if (rrc != MATCH_NOMATCH &&  
924              (rrc != MATCH_THEN || md->start_match_ptr != ecode))          /* If we backed up to a THEN, check whether it is within the current
925            RRETURN(rrc);          branch by comparing the address of the THEN that is passed back with
926            the end of the branch. If it is within the current branch, and the
927            branch is one of two or more alternatives (it either starts or ends
928            with OP_ALT), we have reached the limit of THEN's action, so convert
929            the return code to NOMATCH, which will cause normal backtracking to
930            happen from now on. Otherwise, THEN is passed back to an outer
931            alternative. This implements Perl's treatment of parenthesized groups,
932            where a group not containing | does not affect the current alternative,
933            that is, (X) is NOT the same as (X|(*F)). */
934    
935            if (rrc == MATCH_THEN)
936              {
937              next = ecode + GET(ecode,1);
938              if (md->start_match_ptr < next &&
939                  (*ecode == OP_ALT || *next == OP_ALT))
940                rrc = MATCH_NOMATCH;
941              }
942    
943            /* Anything other than NOMATCH is passed back. */
944    
945            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
946          md->capture_last = save_capture_last;          md->capture_last = save_capture_last;
947          ecode += GET(ecode, 1);          ecode += GET(ecode, 1);
948          if (*ecode != OP_ALT) break;          if (*ecode != OP_ALT) break;
# Line 851  for (;;) Line 953  for (;;)
953        md->offset_vector[offset+1] = save_offset2;        md->offset_vector[offset+1] = save_offset2;
954        md->offset_vector[md->offset_end - number] = save_offset3;        md->offset_vector[md->offset_end - number] = save_offset3;
955    
956        /* At this point, rrc will be one of MATCH_ONCE, MATCH_NOMATCH, or        /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */
       MATCH_THEN. */  
957    
958        if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;        RRETURN(rrc);
       RRETURN(((rrc == MATCH_ONCE)? MATCH_ONCE:MATCH_NOMATCH));  
959        }        }
960    
961      /* FALL THROUGH ... Insufficient room for saving captured contents. Treat      /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
# Line 870  for (;;) Line 970  for (;;)
970      /* VVVVVVVVVVVVVVVVVVVVVVVVV */      /* VVVVVVVVVVVVVVVVVVVVVVVVV */
971    
972      /* Non-capturing or atomic group, except for possessive with unlimited      /* Non-capturing or atomic group, except for possessive with unlimited
973      repeat. Loop for all the alternatives. When we get to the final alternative      repeat and ONCE group with no captures. Loop for all the alternatives.
974      within the brackets, we used to return the result of a recursive call to  
975      match() whatever happened so it was possible to reduce stack usage by      When we get to the final alternative within the brackets, we used to return
976      turning this into a tail recursion, except in the case of a possibly empty      the result of a recursive call to match() whatever happened so it was
977      group. However, now that there is the possiblity of (*THEN) occurring in      possible to reduce stack usage by turning this into a tail recursion,
978      the final alternative, this optimization is no longer possible.      except in the case of a possibly empty group. However, now that there is
979        the possiblity of (*THEN) occurring in the final alternative, this
980        optimization is no longer always possible.
981    
982        We can optimize if we know there are no (*THEN)s in the pattern; at present
983        this is the best that can be done.
984    
985      MATCH_ONCE is returned when the end of an atomic group is successfully      MATCH_ONCE is returned when the end of an atomic group is successfully
986      reached, but subsequent matching fails. It passes back up the tree (causing      reached, but subsequent matching fails. It passes back up the tree (causing
# Line 892  for (;;) Line 997  for (;;)
997      for (;;)      for (;;)
998        {        {
999        if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;        if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;
1000    
1001          /* If this is not a possibly empty group, and there are no (*THEN)s in
1002          the pattern, and this is the final alternative, optimize as described
1003          above. */
1004    
1005          else if (!md->hasthen && ecode[GET(ecode, 1)] != OP_ALT)
1006            {
1007            ecode += _pcre_OP_lengths[*ecode];
1008            goto TAIL_RECURSE;
1009            }
1010    
1011          /* In all other cases, we have to make another call to match(). */
1012    
1013        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,
1014          RM2);          RM2);
1015        if (rrc != MATCH_NOMATCH &&  
1016            (rrc != MATCH_THEN || md->start_match_ptr != ecode))        /* See comment in the code for capturing groups above about handling
1017          THEN. */
1018    
1019          if (rrc == MATCH_THEN)
1020            {
1021            next = ecode + GET(ecode,1);
1022            if (md->start_match_ptr < next &&
1023                (*ecode == OP_ALT || *next == OP_ALT))
1024              rrc = MATCH_NOMATCH;
1025            }
1026    
1027          if (rrc != MATCH_NOMATCH)
1028          {          {
1029          if (rrc == MATCH_ONCE)          if (rrc == MATCH_ONCE)
1030            {            {
# Line 912  for (;;) Line 1041  for (;;)
1041        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1042        if (*ecode != OP_ALT) break;        if (*ecode != OP_ALT) break;
1043        }        }
1044      if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;  
1045      RRETURN(MATCH_NOMATCH);      RRETURN(MATCH_NOMATCH);
1046    
1047      /* Handle possessive capturing brackets with an unlimited repeat. We come      /* Handle possessive capturing brackets with an unlimited repeat. We come
# Line 975  for (;;) Line 1104  for (;;)
1104            matched_once = TRUE;            matched_once = TRUE;
1105            continue;            continue;
1106            }            }
1107          if (rrc != MATCH_NOMATCH &&  
1108              (rrc != MATCH_THEN || md->start_match_ptr != ecode))          /* See comment in the code for capturing groups above about handling
1109            RRETURN(rrc);          THEN. */
1110    
1111            if (rrc == MATCH_THEN)
1112              {
1113              next = ecode + GET(ecode,1);
1114              if (md->start_match_ptr < next &&
1115                  (*ecode == OP_ALT || *next == OP_ALT))
1116                rrc = MATCH_NOMATCH;
1117              }
1118    
1119            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1120          md->capture_last = save_capture_last;          md->capture_last = save_capture_last;
1121          ecode += GET(ecode, 1);          ecode += GET(ecode, 1);
1122          if (*ecode != OP_ALT) break;          if (*ecode != OP_ALT) break;
# Line 990  for (;;) Line 1129  for (;;)
1129          md->offset_vector[md->offset_end - number] = save_offset3;          md->offset_vector[md->offset_end - number] = save_offset3;
1130          }          }
1131    
       if (rrc != MATCH_THEN && md->mark == NULL) md->mark = markptr;  
1132        if (allow_zero || matched_once)        if (allow_zero || matched_once)
1133          {          {
1134          ecode += 1 + LINK_SIZE;          ecode += 1 + LINK_SIZE;
# Line 1037  for (;;) Line 1175  for (;;)
1175          matched_once = TRUE;          matched_once = TRUE;
1176          continue;          continue;
1177          }          }
1178        if (rrc != MATCH_NOMATCH &&  
1179            (rrc != MATCH_THEN || md->start_match_ptr != ecode))        /* See comment in the code for capturing groups above about handling
1180          RRETURN(rrc);        THEN. */
1181    
1182          if (rrc == MATCH_THEN)
1183            {
1184            next = ecode + GET(ecode,1);
1185            if (md->start_match_ptr < next &&
1186                (*ecode == OP_ALT || *next == OP_ALT))
1187              rrc = MATCH_NOMATCH;
1188            }
1189    
1190          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1191        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1192        if (*ecode != OP_ALT) break;        if (*ecode != OP_ALT) break;
1193        }        }
# Line 1082  for (;;) Line 1230  for (;;)
1230          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
1231          cb.capture_last     = md->capture_last;          cb.capture_last     = md->capture_last;
1232          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
1233          cb.mark             = markptr;          cb.mark             = md->nomatch_mark;
1234          if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);          if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1235          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
1236          }          }
1237        ecode += _pcre_OP_lengths[OP_CALLOUT];        ecode += _pcre_OP_lengths[OP_CALLOUT];
# Line 1103  for (;;) Line 1251  for (;;)
1251        else        else
1252          {          {
1253          int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/          int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
1254          condition =  (recno == RREF_ANY || recno == md->recursive->group_num);          condition = (recno == RREF_ANY || recno == md->recursive->group_num);
1255    
1256          /* If the test is for recursion into a specific subpattern, and it is          /* If the test is for recursion into a specific subpattern, and it is
1257          false, but the test was set up by name, scan the table to see if the          false, but the test was set up by name, scan the table to see if the
1258          name refers to any other numbers, and test them. The condition is true          name refers to any other numbers, and test them. The condition is true
1259          if any one is set. */          if any one is set. */
1260    
1261          if (!condition && condcode == OP_NRREF && recno != RREF_ANY)          if (!condition && condcode == OP_NRREF)
1262            {            {
1263            uschar *slotA = md->name_table;            uschar *slotA = md->name_table;
1264            for (i = 0; i < md->name_count; i++)            for (i = 0; i < md->name_count; i++)
# Line 1251  for (;;) Line 1399  for (;;)
1399          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
1400          while (*ecode == OP_ALT) ecode += GET(ecode, 1);          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
1401          }          }
1402        else if (rrc != MATCH_NOMATCH &&  
1403                (rrc != MATCH_THEN || md->start_match_ptr != ecode))        /* PCRE doesn't allow the effect of (*THEN) to escape beyond an
1404          assertion; it is therefore treated as NOMATCH. */
1405    
1406          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1407          {          {
1408          RRETURN(rrc);         /* Need braces because of following else */          RRETURN(rrc);         /* Need braces because of following else */
1409          }          }
# Line 1263  for (;;) Line 1414  for (;;)
1414          }          }
1415        }        }
1416    
1417      /* We are now at the branch that is to be obeyed. As there is only one,      /* We are now at the branch that is to be obeyed. As there is only one, can
1418      we used to use tail recursion to avoid using another stack frame, except      use tail recursion to avoid using another stack frame, except when there is
1419      when there was unlimited repeat of a possibly empty group. However, that      unlimited repeat of a possibly empty group. In the latter case, a recursive
1420      strategy no longer works because of the possibilty of (*THEN) being      call to match() is always required, unless the second alternative doesn't
1421      encountered in the branch. A recursive call to match() is always required,      exist, in which case we can just plough on. Note that, for compatibility
1422      unless the second alternative doesn't exist, in which case we can just      with Perl, the | in a conditional group is NOT treated as creating two
1423      plough on. */      alternatives. If a THEN is encountered in the branch, it propagates out to
1424        the enclosing alternative (unless nested in a deeper set of alternatives,
1425        of course). */
1426    
1427      if (condition || *ecode == OP_ALT)      if (condition || *ecode == OP_ALT)
1428        {        {
1429        if (op == OP_SCOND) md->match_function_type = MATCH_CBEGROUP;        if (op != OP_SCOND)
1430            {
1431            ecode += 1 + LINK_SIZE;
1432            goto TAIL_RECURSE;
1433            }
1434    
1435          md->match_function_type = MATCH_CBEGROUP;
1436        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM49);
       if (rrc == MATCH_THEN && md->start_match_ptr == ecode)  
         rrc = MATCH_NOMATCH;  
1437        RRETURN(rrc);        RRETURN(rrc);
1438        }        }
1439      else                         /* Condition false & no alternative */  
1440         /* Condition false & no alternative; continue after the group. */
1441    
1442        else
1443        {        {
1444        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
1445        }        }
# Line 1326  for (;;) Line 1486  for (;;)
1486           (md->notempty ||           (md->notempty ||
1487             (md->notempty_atstart &&             (md->notempty_atstart &&
1488               mstart == md->start_subject + md->start_offset)))               mstart == md->start_subject + md->start_offset)))
1489        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
1490    
1491      /* Otherwise, we have a match. */      /* Otherwise, we have a match. */
1492    
# Line 1335  for (;;) Line 1495  for (;;)
1495      md->start_match_ptr = mstart;       /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
1496    
1497      /* For some reason, the macros don't work properly if an expression is      /* For some reason, the macros don't work properly if an expression is
1498      given as the argument to MRRETURN when the heap is in use. */      given as the argument to RRETURN when the heap is in use. */
1499    
1500      rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;      rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
1501      MRRETURN(rrc);      RRETURN(rrc);
1502    
1503      /* Assertion brackets. Check the alternative branches in turn - the      /* Assertion brackets. Check the alternative branches in turn - the
1504      matching won't pass the KET for an assertion. If any one branch matches,      matching won't pass the KET for an assertion. If any one branch matches,
# Line 1366  for (;;) Line 1526  for (;;)
1526        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1527          {          {
1528          mstart = md->start_match_ptr;   /* In case \K reset it */          mstart = md->start_match_ptr;   /* In case \K reset it */
         markptr = md->mark;  
1529          break;          break;
1530          }          }
1531        if (rrc != MATCH_NOMATCH &&  
1532            (rrc != MATCH_THEN || md->start_match_ptr != ecode))        /* PCRE does not allow THEN to escape beyond an assertion; it is treated
1533          RRETURN(rrc);        as NOMATCH. */
1534    
1535          if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1536        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1537        }        }
1538      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1539    
1540      if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH);      if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
1541    
1542      /* If checking an assertion for a condition, return MATCH_MATCH. */      /* If checking an assertion for a condition, return MATCH_MATCH. */
1543    
# Line 1406  for (;;) Line 1567  for (;;)
1567      do      do
1568        {        {
1569        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
1570        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);
1571        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1572          {          {
1573          do ecode += GET(ecode,1); while (*ecode == OP_ALT);          do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1574          break;          break;
1575          }          }
1576        if (rrc != MATCH_NOMATCH &&  
1577            (rrc != MATCH_THEN || md->start_match_ptr != ecode))        /* PCRE does not allow THEN to escape beyond an assertion; it is treated
1578          RRETURN(rrc);        as NOMATCH. */
1579    
1580          if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1581        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1582        }        }
1583      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 1437  for (;;) Line 1600  for (;;)
1600        while (i-- > 0)        while (i-- > 0)
1601          {          {
1602          eptr--;          eptr--;
1603          if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1604          BACKCHAR(eptr);          BACKCHAR(eptr);
1605          }          }
1606        }        }
# Line 1448  for (;;) Line 1611  for (;;)
1611    
1612        {        {
1613        eptr -= GET(ecode, 1);        eptr -= GET(ecode, 1);
1614        if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH);        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
1615        }        }
1616    
1617      /* Save the earliest consulted character, then skip to next op code */      /* Save the earliest consulted character, then skip to next op code */
# Line 1477  for (;;) Line 1640  for (;;)
1640        cb.capture_top      = offset_top/2;        cb.capture_top      = offset_top/2;
1641        cb.capture_last     = md->capture_last;        cb.capture_last     = md->capture_last;
1642        cb.callout_data     = md->callout_data;        cb.callout_data     = md->callout_data;
1643        cb.mark             = markptr;        cb.mark             = md->nomatch_mark;
1644        if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH);        if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1645        if (rrc < 0) RRETURN(rrc);        if (rrc < 0) RRETURN(rrc);
1646        }        }
1647      ecode += 2 + 2*LINK_SIZE;      ecode += 2 + 2*LINK_SIZE;
# Line 1505  for (;;) Line 1668  for (;;)
1668        {        {
1669        recursion_info *ri;        recursion_info *ri;
1670        int recno;        int recno;
1671    
1672        callpat = md->start_code + GET(ecode, 1);        callpat = md->start_code + GET(ecode, 1);
1673        recno = (callpat == md->start_code)? 0 :        recno = (callpat == md->start_code)? 0 :
1674          GET2(callpat, 1 + LINK_SIZE);          GET2(callpat, 1 + LINK_SIZE);
1675    
1676        /* Check for repeating a recursion without advancing the subject pointer.        /* Check for repeating a recursion without advancing the subject pointer.
1677        This should catch convoluted mutual recursions. (Some simple cases are        This should catch convoluted mutual recursions. (Some simple cases are
1678        caught at compile time.) */        caught at compile time.) */
1679    
1680        for (ri = md->recursive; ri != NULL; ri = ri->prevrec)        for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
1681          if (recno == ri->group_num && eptr == ri->subject_position)          if (recno == ri->group_num && eptr == ri->subject_position)
1682            RRETURN(PCRE_ERROR_RECURSELOOP);            RRETURN(PCRE_ERROR_RECURSELOOP);
1683    
1684        /* Add to "recursing stack" */        /* Add to "recursing stack" */
# Line 1556  for (;;) Line 1719  for (;;)
1719            md, eptrb, RM6);            md, eptrb, RM6);
1720          memcpy(md->offset_vector, new_recursive.offset_save,          memcpy(md->offset_vector, new_recursive.offset_save,
1721              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
1722            md->recursive = new_recursive.prevrec;
1723          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1724            {            {
1725            DPRINTF(("Recursion matched\n"));            DPRINTF(("Recursion matched\n"));
           md->recursive = new_recursive.prevrec;  
1726            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1727              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1728    
# Line 1571  for (;;) Line 1734  for (;;)
1734            mstart = md->start_match_ptr;            mstart = md->start_match_ptr;
1735            goto RECURSION_MATCHED;        /* Exit loop; end processing */            goto RECURSION_MATCHED;        /* Exit loop; end processing */
1736            }            }
1737          else if (rrc != MATCH_NOMATCH &&  
1738                  (rrc != MATCH_THEN || md->start_match_ptr != ecode))          /* PCRE does not allow THEN to escape beyond a recursion; it is treated
1739            as NOMATCH. */
1740    
1741            else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1742            {            {
1743            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1744            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
# Line 1589  for (;;) Line 1755  for (;;)
1755        md->recursive = new_recursive.prevrec;        md->recursive = new_recursive.prevrec;
1756        if (new_recursive.offset_save != stacksave)        if (new_recursive.offset_save != stacksave)
1757          (pcre_free)(new_recursive.offset_save);          (pcre_free)(new_recursive.offset_save);
1758        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
1759        }        }
1760    
1761      RECURSION_MATCHED:      RECURSION_MATCHED:
# Line 1658  for (;;) Line 1824  for (;;)
1824        }        }
1825      else saved_eptr = NULL;      else saved_eptr = NULL;
1826    
1827      /* 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 a non-capturing atomic
1828      MATCH_MATCH, but record the current high water mark for use by positive      group, stop matching and return MATCH_MATCH, but record the current high
1829      assertions. We also need to record the match start in case it was changed      water mark for use by positive assertions. We also need to record the match
1830      by \K. */      start in case it was changed by \K. */
1831    
1832      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||      if ((*prev >= OP_ASSERT && *prev <= OP_ASSERTBACK_NOT) ||
1833          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT)           *prev == OP_ONCE_NC)
1834        {        {
1835        md->end_match_ptr = eptr;      /* For ONCE */        md->end_match_ptr = eptr;      /* For ONCE_NC */
1836        md->end_offset_top = offset_top;        md->end_offset_top = offset_top;
1837        md->start_match_ptr = mstart;        md->start_match_ptr = mstart;
1838        MRRETURN(MATCH_MATCH);         /* Sets md->mark */        RRETURN(MATCH_MATCH);         /* Sets md->mark */
1839        }        }
1840    
1841      /* 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 1734  for (;;) Line 1900  for (;;)
1900      /* For an ordinary non-repeating ket, just continue at this level. This      /* For an ordinary non-repeating ket, just continue at this level. This
1901      also happens for a repeating ket if no characters were matched in the      also happens for a repeating ket if no characters were matched in the
1902      group. This is the forcible breaking of infinite loops as implemented in      group. This is the forcible breaking of infinite loops as implemented in
1903      Perl 5.005. For a non-repeating atomic group, establish a backup point by      Perl 5.005. For a non-repeating atomic group that includes captures,
1904      processing the rest of the pattern at a lower level. If this results in a      establish a backup point by processing the rest of the pattern at a lower
1905      NOMATCH return, pass MATCH_ONCE back to the original OP_ONCE level, thereby      level. If this results in a NOMATCH return, pass MATCH_ONCE back to the
1906      bypassing intermediate backup points, but resetting any captures that      original OP_ONCE level, thereby bypassing intermediate backup points, but
1907      happened along the way. */      resetting any captures that happened along the way. */
1908    
1909      if (*ecode == OP_KET || eptr == saved_eptr)      if (*ecode == OP_KET || eptr == saved_eptr)
1910        {        {
# Line 1811  for (;;) Line 1977  for (;;)
1977      /* Not multiline mode: start of subject assertion, unless notbol. */      /* Not multiline mode: start of subject assertion, unless notbol. */
1978    
1979      case OP_CIRC:      case OP_CIRC:
1980      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
1981    
1982      /* Start of subject assertion */      /* Start of subject assertion */
1983    
1984      case OP_SOD:      case OP_SOD:
1985      if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
1986      ecode++;      ecode++;
1987      break;      break;
1988    
1989      /* Multiline mode: start of subject unless notbol, or after any newline. */      /* Multiline mode: start of subject unless notbol, or after any newline. */
1990    
1991      case OP_CIRCM:      case OP_CIRCM:
1992      if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH);      if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
1993      if (eptr != md->start_subject &&      if (eptr != md->start_subject &&
1994          (eptr == md->end_subject || !WAS_NEWLINE(eptr)))          (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
1995        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
1996      ecode++;      ecode++;
1997      break;      break;
1998    
1999      /* Start of match assertion */      /* Start of match assertion */
2000    
2001      case OP_SOM:      case OP_SOM:
2002      if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH);      if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);
2003      ecode++;      ecode++;
2004      break;      break;
2005    
# Line 1849  for (;;) Line 2015  for (;;)
2015    
2016      case OP_DOLLM:      case OP_DOLLM:
2017      if (eptr < md->end_subject)      if (eptr < md->end_subject)
2018        { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); }        { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }
2019      else      else
2020        {        {
2021        if (md->noteol) MRRETURN(MATCH_NOMATCH);        if (md->noteol) RRETURN(MATCH_NOMATCH);
2022        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2023        }        }
2024      ecode++;      ecode++;
# Line 1862  for (;;) Line 2028  for (;;)
2028      subject unless noteol is set. */      subject unless noteol is set. */
2029    
2030      case OP_DOLL:      case OP_DOLL:
2031      if (md->noteol) MRRETURN(MATCH_NOMATCH);      if (md->noteol) RRETURN(MATCH_NOMATCH);
2032      if (!md->endonly) goto ASSERT_NL_OR_EOS;      if (!md->endonly) goto ASSERT_NL_OR_EOS;
2033    
2034      /* ... else fall through for endonly */      /* ... else fall through for endonly */
# Line 1870  for (;;) Line 2036  for (;;)
2036      /* End of subject assertion (\z) */      /* End of subject assertion (\z) */
2037    
2038      case OP_EOD:      case OP_EOD:
2039      if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH);      if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
2040      SCHECK_PARTIAL();      SCHECK_PARTIAL();
2041      ecode++;      ecode++;
2042      break;      break;
# Line 1881  for (;;) Line 2047  for (;;)
2047      ASSERT_NL_OR_EOS:      ASSERT_NL_OR_EOS:
2048      if (eptr < md->end_subject &&      if (eptr < md->end_subject &&
2049          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
2050        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2051    
2052      /* Either at end of string or \n before end. */      /* Either at end of string or \n before end. */
2053    
# Line 2003  for (;;) Line 2169  for (;;)
2169    
2170        if ((*ecode++ == OP_WORD_BOUNDARY)?        if ((*ecode++ == OP_WORD_BOUNDARY)?
2171             cur_is_word == prev_is_word : cur_is_word != prev_is_word)             cur_is_word == prev_is_word : cur_is_word != prev_is_word)
2172          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2173        }        }
2174      break;      break;
2175    
2176      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
2177    
2178      case OP_ANY:      case OP_ANY:
2179      if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
2180      /* Fall through */      /* Fall through */
2181    
2182      case OP_ALLANY:      case OP_ALLANY:
2183      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
2184        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
2185        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2186        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2187        }        }
2188      eptr++;      eptr++;
2189      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 2031  for (;;) Line 2197  for (;;)
2197      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
2198        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
2199        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2200        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2201        }        }
2202      eptr++;      eptr++;
2203      ecode++;      ecode++;
2204      break;      break;
2205    
# Line 2041  for (;;) Line 2207  for (;;)
2207      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2208        {        {
2209        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2210        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2211        }        }
2212      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2213      if (      if (
# Line 2050  for (;;) Line 2216  for (;;)
2216  #endif  #endif
2217         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
2218         )         )
2219        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2220      ecode++;      ecode++;
2221      break;      break;
2222    
# Line 2058  for (;;) Line 2224  for (;;)
2224      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2225        {        {
2226        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2227        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2228        }        }
2229      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2230      if (      if (
# Line 2067  for (;;) Line 2233  for (;;)
2233  #endif  #endif
2234         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
2235         )         )
2236        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2237      ecode++;      ecode++;
2238      break;      break;
2239    
# Line 2075  for (;;) Line 2241  for (;;)
2241      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2242        {        {
2243        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2244        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2245        }        }
2246      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2247      if (      if (
# Line 2084  for (;;) Line 2250  for (;;)
2250  #endif  #endif
2251         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
2252         )         )
2253        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2254      ecode++;      ecode++;
2255      break;      break;
2256    
# Line 2092  for (;;) Line 2258  for (;;)
2258      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2259        {        {
2260        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2261        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2262        }        }
2263      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2264      if (      if (
# Line 2101  for (;;) Line 2267  for (;;)
2267  #endif  #endif
2268         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
2269         )         )
2270        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2271      ecode++;      ecode++;
2272      break;      break;
2273    
# Line 2109  for (;;) Line 2275  for (;;)
2275      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2276        {        {
2277        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2278        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2279        }        }
2280      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2281      if (      if (
# Line 2118  for (;;) Line 2284  for (;;)
2284  #endif  #endif
2285         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
2286         )         )
2287        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2288      ecode++;      ecode++;
2289      break;      break;
2290    
# Line 2126  for (;;) Line 2292  for (;;)
2292      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2293        {        {
2294        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2295        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2296        }        }
2297      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2298      if (      if (
# Line 2135  for (;;) Line 2301  for (;;)
2301  #endif  #endif
2302         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
2303         )         )
2304        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2305      ecode++;      ecode++;
2306      break;      break;
2307    
# Line 2143  for (;;) Line 2309  for (;;)
2309      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2310        {        {
2311        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2312        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2313        }        }
2314      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2315      switch(c)      switch(c)
2316        {        {
2317        default: MRRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2318    
2319        case 0x000d:        case 0x000d:
2320        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
# Line 2162  for (;;) Line 2328  for (;;)
2328        case 0x0085:        case 0x0085:
2329        case 0x2028:        case 0x2028:
2330        case 0x2029:        case 0x2029:
2331        if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2332        break;        break;
2333        }        }
2334      ecode++;      ecode++;
# Line 2172  for (;;) Line 2338  for (;;)
2338      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2339        {        {
2340        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2341        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2342        }        }
2343      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2344      switch(c)      switch(c)
# Line 2197  for (;;) Line 2363  for (;;)
2363        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2364        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2365        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2366        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2367        }        }
2368      ecode++;      ecode++;
2369      break;      break;
# Line 2206  for (;;) Line 2372  for (;;)
2372      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2373        {        {
2374        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2375        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2376        }        }
2377      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2378      switch(c)      switch(c)
2379        {        {
2380        default: MRRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2381        case 0x09:      /* HT */        case 0x09:      /* HT */
2382        case 0x20:      /* SPACE */        case 0x20:      /* SPACE */
2383        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
# Line 2240  for (;;) Line 2406  for (;;)
2406      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2407        {        {
2408        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2409        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2410        }        }
2411      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2412      switch(c)      switch(c)
# Line 2253  for (;;) Line 2419  for (;;)
2419        case 0x85:      /* NEL */        case 0x85:      /* NEL */
2420        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2421        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2422        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2423        }        }
2424      ecode++;      ecode++;
2425      break;      break;
# Line 2262  for (;;) Line 2428  for (;;)
2428      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2429        {        {
2430        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2431        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2432        }        }
2433      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2434      switch(c)      switch(c)
2435        {        {
2436        default: MRRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2437        case 0x0a:      /* LF */        case 0x0a:      /* LF */
2438        case 0x0b:      /* VT */        case 0x0b:      /* VT */
2439        case 0x0c:      /* FF */        case 0x0c:      /* FF */
# Line 2289  for (;;) Line 2455  for (;;)
2455      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2456        {        {
2457        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2458        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2459        }        }
2460      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2461        {        {
# Line 2298  for (;;) Line 2464  for (;;)
2464        switch(ecode[1])        switch(ecode[1])
2465          {          {
2466          case PT_ANY:          case PT_ANY:
2467          if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH);          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
2468          break;          break;
2469    
2470          case PT_LAMP:          case PT_LAMP:
2471          if ((prop->chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
2472               prop->chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
2473               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
2474            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2475          break;          break;
2476    
2477          case PT_GC:          case PT_GC:
2478          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
2479            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2480          break;          break;
2481    
2482          case PT_PC:          case PT_PC:
2483          if ((ecode[2] != prop->chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
2484            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2485          break;          break;
2486    
2487          case PT_SC:          case PT_SC:
2488          if ((ecode[2] != prop->script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
2489            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2490          break;          break;
2491    
2492          /* These are specials */          /* These are specials */
# Line 2328  for (;;) Line 2494  for (;;)
2494          case PT_ALNUM:          case PT_ALNUM:
2495          if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||          if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2496               _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))               _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2497            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2498          break;          break;
2499    
2500          case PT_SPACE:    /* Perl space */          case PT_SPACE:    /* Perl space */
2501          if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||          if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||
2502               c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)               c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2503                 == (op == OP_NOTPROP))                 == (op == OP_NOTPROP))
2504            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2505          break;          break;
2506    
2507          case PT_PXSPACE:  /* POSIX space */          case PT_PXSPACE:  /* POSIX space */
# Line 2343  for (;;) Line 2509  for (;;)
2509               c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||               c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2510               c == CHAR_FF || c == CHAR_CR)               c == CHAR_FF || c == CHAR_CR)
2511                 == (op == OP_NOTPROP))                 == (op == OP_NOTPROP))
2512            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2513          break;          break;
2514    
2515          case PT_WORD:          case PT_WORD:
2516          if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||          if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||
2517               _pcre_ucp_gentype[prop->chartype] == ucp_N ||               _pcre_ucp_gentype[prop->chartype] == ucp_N ||
2518               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2519            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2520          break;          break;
2521    
2522          /* This should never occur */          /* This should never occur */
# Line 2370  for (;;) Line 2536  for (;;)
2536      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
2537        {        {
2538        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2539        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2540        }        }
2541      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2542      if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);      if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);
2543      while (eptr < md->end_subject)      while (eptr < md->end_subject)
2544        {        {
2545        int len = 1;        int len = 1;
# Line 2447  for (;;) Line 2613  for (;;)
2613        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2614          {          {
2615          CHECK_PARTIAL();          CHECK_PARTIAL();
2616          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2617          }          }
2618        eptr += length;        eptr += length;
2619        continue;              /* With the main loop */        continue;              /* With the main loop */
# Line 2468  for (;;) Line 2634  for (;;)
2634        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2635          {          {
2636          CHECK_PARTIAL();          CHECK_PARTIAL();
2637          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2638          }          }
2639        eptr += slength;        eptr += slength;
2640        }        }
# Line 2487  for (;;) Line 2653  for (;;)
2653          int slength;          int slength;
2654          RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
2655          if (rrc != MATCH_NOMATCH) RRETURN(rrc);          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2656          if (fi >= max) MRRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2657          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2658            {            {
2659            CHECK_PARTIAL();            CHECK_PARTIAL();
2660            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2661            }            }
2662          eptr += slength;          eptr += slength;
2663          }          }
# Line 2519  for (;;) Line 2685  for (;;)
2685          if (rrc != MATCH_NOMATCH) RRETURN(rrc);          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2686          eptr -= length;          eptr -= length;
2687          }          }
2688        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2689        }        }
2690      /* Control never gets here */      /* Control never gets here */
2691    
# Line 2580  for (;;) Line 2746  for (;;)
2746            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2747              {              {
2748              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2749              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2750              }              }
2751            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
2752            if (c > 255)            if (c > 255)
2753              {              {
2754              if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2755              }              }
2756            else            else
2757              {              {
2758              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2759              }              }
2760            }            }
2761          }          }
# Line 2602  for (;;) Line 2768  for (;;)
2768            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2769              {              {
2770              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2771              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2772              }              }
2773            c = *eptr++;            c = *eptr++;
2774            if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2775            }            }
2776          }          }
2777    
# Line 2627  for (;;) Line 2793  for (;;)
2793              {              {
2794              RMATCH(eptr, ecode, offset_top, md, eptrb, RM16);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM16);
2795              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2796              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
2797              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2798                {                {
2799                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2800                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2801                }                }
2802              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
2803              if (c > 255)              if (c > 255)
2804                {                {
2805                if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2806                }                }
2807              else              else
2808                {                {
2809                if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);                if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2810                }                }
2811              }              }
2812            }            }
# Line 2652  for (;;) Line 2818  for (;;)
2818              {              {
2819              RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);
2820              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2821              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
2822              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
2823                {                {
2824                SCHECK_PARTIAL();                SCHECK_PARTIAL();
2825                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2826                }                }
2827              c = *eptr++;              c = *eptr++;
2828              if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH);              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2829              }              }
2830            }            }
2831          /* Control never gets here */          /* Control never gets here */
# Line 2725  for (;;) Line 2891  for (;;)
2891              }              }
2892            }            }
2893    
2894          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2895          }          }
2896        }        }
2897      /* Control never gets here */      /* Control never gets here */
# Line 2777  for (;;) Line 2943  for (;;)
2943          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
2944            {            {
2945            SCHECK_PARTIAL();            SCHECK_PARTIAL();
2946            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2947            }            }
2948          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
2949          if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2950          }          }
2951    
2952        /* 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 2797  for (;;) Line 2963  for (;;)
2963            {            {
2964            RMATCH(eptr, ecode, offset_top, md, eptrb, RM20);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM20);
2965            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2966            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
2967            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
2968              {              {
2969              SCHECK_PARTIAL();              SCHECK_PARTIAL();
2970              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2971              }              }
2972            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2973            if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2974            }            }
2975          /* Control never gets here */          /* Control never gets here */
2976          }          }
# Line 2833  for (;;) Line 2999  for (;;)
2999            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3000            if (utf8) BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
3001            }            }
3002          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3003          }          }
3004    
3005        /* Control never gets here */        /* Control never gets here */
# Line 2852  for (;;) Line 3018  for (;;)
3018        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
3019          {          {
3020          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
3021          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3022          }          }
3023        while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
3024        }        }
3025      else      else
3026  #endif  #endif
# Line 2864  for (;;) Line 3030  for (;;)
3030        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
3031          {          {
3032          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
3033          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3034          }          }
3035        if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH);        if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
3036        ecode += 2;        ecode += 2;
3037        }        }
3038      break;      break;
# Line 2884  for (;;) Line 3050  for (;;)
3050        if (length > md->end_subject - eptr)        if (length > md->end_subject - eptr)
3051          {          {
3052          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
3053          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3054          }          }
3055    
3056        /* 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 2892  for (;;) Line 3058  for (;;)
3058    
3059        if (fc < 128)        if (fc < 128)
3060          {          {
3061          if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3062          }          }
3063    
3064        /* Otherwise we must pick up the subject character */        /* Otherwise we must pick up the subject character */
# Line 2911  for (;;) Line 3077  for (;;)
3077  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3078            if (dc != UCD_OTHERCASE(fc))            if (dc != UCD_OTHERCASE(fc))
3079  #endif  #endif
3080              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3081            }            }
3082          }          }
3083        }        }
# Line 2923  for (;;) Line 3089  for (;;)
3089        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
3090          {          {
3091          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */          SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
3092          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3093          }          }
3094        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3095        ecode += 2;        ecode += 2;
3096        }        }
3097      break;      break;
# Line 3031  for (;;) Line 3197  for (;;)
3197            else            else
3198              {              {
3199              CHECK_PARTIAL();              CHECK_PARTIAL();
3200              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3201              }              }
3202            }            }
3203    
# Line 3043  for (;;) Line 3209  for (;;)
3209              {              {
3210              RMATCH(eptr, ecode, offset_top, md, eptrb, RM22);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM22);
3211              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3212              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3213              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
3214                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, length) == 0) eptr += length;
3215  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 3054  for (;;) Line 3220  for (;;)
3220              else              else
3221                {                {
3222                CHECK_PARTIAL();                CHECK_PARTIAL();
3223                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3224                }                }
3225              }              }
3226            /* Control never gets here */            /* Control never gets here */
# Line 3085  for (;;) Line 3251  for (;;)
3251              {              {
3252              RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);
3253              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3254              if (eptr == pp) { MRRETURN(MATCH_NOMATCH); }              if (eptr == pp) { RRETURN(MATCH_NOMATCH); }
3255  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3256              eptr--;              eptr--;
3257              BACKCHAR(eptr);              BACKCHAR(eptr);
# Line 3128  for (;;) Line 3294  for (;;)
3294          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
3295            {            {
3296            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3297            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3298            }            }
3299          if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3300          }          }
3301        if (min == max) continue;        if (min == max) continue;
3302        if (minimize)        if (minimize)
# Line 3139  for (;;) Line 3305  for (;;)
3305            {            {
3306            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
3307            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3308            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
3309            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3310              {              {
3311              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3312              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3313              }              }
3314            if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3315            }            }
3316          /* Control never gets here */          /* Control never gets here */
3317          }          }
# Line 3171  for (;;) Line 3337  for (;;)
3337            eptr--;            eptr--;
3338            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3339            }            }
3340          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3341          }          }
3342        /* Control never gets here */        /* Control never gets here */
3343        }        }
# Line 3185  for (;;) Line 3351  for (;;)
3351          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
3352            {            {
3353            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3354            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3355            }            }
3356          if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
3357          }          }
3358    
3359        if (min == max) continue;        if (min == max) continue;
# Line 3198  for (;;) Line 3364  for (;;)
3364            {            {
3365            RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);
3366            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3367            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
3368            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3369              {              {
3370              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3371              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3372              }              }
3373            if (fc != *eptr++) MRRETURN(MATCH_NOMATCH);            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
3374            }            }
3375          /* Control never gets here */          /* Control never gets here */
3376          }          }
# Line 3229  for (;;) Line 3395  for (;;)
3395            eptr--;            eptr--;
3396            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3397            }            }
3398          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3399          }          }
3400        }        }
3401      /* Control never gets here */      /* Control never gets here */
# Line 3242  for (;;) Line 3408  for (;;)
3408      if (eptr >= md->end_subject)      if (eptr >= md->end_subject)
3409        {        {
3410        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3411        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3412        }        }
3413      ecode++;      ecode++;
3414      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
# Line 3252  for (;;) Line 3418  for (;;)
3418        if (c < 256)        if (c < 256)
3419  #endif  #endif
3420        c = md->lcc[c];        c = md->lcc[c];
3421        if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH);        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);
3422        }        }
3423      else    /* Caseful */      else    /* Caseful */
3424        {        {
3425        if (*ecode++ == c) MRRETURN(MATCH_NOMATCH);        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);
3426        }        }
3427      break;      break;
3428    
# Line 3363  for (;;) Line 3529  for (;;)
3529            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3530              {              {
3531              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3532              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3533              }              }
3534            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3535            if (d < 256) d = md->lcc[d];            if (d < 256) d = md->lcc[d];
3536            if (fc == d) MRRETURN(MATCH_NOMATCH);            if (fc == d) RRETURN(MATCH_NOMATCH);
3537            }            }
3538          }          }
3539        else        else
# Line 3380  for (;;) Line 3546  for (;;)
3546            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3547              {              {
3548              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3549              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3550              }              }
3551            if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3552            }            }
3553          }          }
3554    
# Line 3399  for (;;) Line 3565  for (;;)
3565              {              {
3566              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
3567              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3568              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3569              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3570                {                {
3571                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3572                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3573                }                }
3574              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3575              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
3576              if (fc == d) MRRETURN(MATCH_NOMATCH);              if (fc == d) RRETURN(MATCH_NOMATCH);
3577              }              }
3578            }            }
3579          else          else
# Line 3418  for (;;) Line 3584  for (;;)
3584              {              {
3585              RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);
3586              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3587              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3588              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3589                {                {
3590                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3591                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3592                }                }
3593              if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH);              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
3594              }              }
3595            }            }
3596          /* Control never gets here */          /* Control never gets here */
# Line 3486  for (;;) Line 3652  for (;;)
3652              }              }
3653            }            }
3654    
3655          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3656          }          }
3657        /* Control never gets here */        /* Control never gets here */
3658        }        }
# Line 3505  for (;;) Line 3671  for (;;)
3671            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3672              {              {
3673              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3674              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3675              }              }
3676            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3677            if (fc == d) MRRETURN(MATCH_NOMATCH);            if (fc == d) RRETURN(MATCH_NOMATCH);
3678            }            }
3679          }          }
3680        else        else
# Line 3520  for (;;) Line 3686  for (;;)
3686            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3687              {              {
3688              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3689              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3690              }              }
3691            if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
3692            }            }
3693          }          }
3694    
# Line 3539  for (;;) Line 3705  for (;;)
3705              {              {
3706              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
3707              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3708              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3709              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3710                {                {
3711                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3712                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3713                }                }
3714              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3715              if (fc == d) MRRETURN(MATCH_NOMATCH);              if (fc == d) RRETURN(MATCH_NOMATCH);
3716              }              }
3717            }            }
3718          else          else
# Line 3557  for (;;) Line 3723  for (;;)
3723              {              {
3724              RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);
3725              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3726              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3727              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3728                {                {
3729                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3730                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3731                }                }
3732              if (fc == *eptr++) MRRETURN(MATCH_NOMATCH);              if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
3733              }              }
3734            }            }
3735          /* Control never gets here */          /* Control never gets here */
# Line 3624  for (;;) Line 3790  for (;;)
3790              }              }
3791            }            }
3792    
3793          MRRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3794          }          }
3795        }        }
3796      /* Control never gets here */      /* Control never gets here */
# Line 3718  for (;;) Line 3884  for (;;)
3884          switch(prop_type)          switch(prop_type)
3885            {            {
3886            case PT_ANY:            case PT_ANY:
3887            if (prop_fail_result) MRRETURN(MATCH_NOMATCH);            if (prop_fail_result) RRETURN(MATCH_NOMATCH);
3888            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
3889              {              {
3890              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3891                {                {
3892                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3893                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3894                }                }
3895              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3896              }              }
# Line 3737  for (;;) Line 3903  for (;;)
3903              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3904                {                {
3905                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3906                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3907                }                }
3908              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3909              chartype = UCD_CHARTYPE(c);              chartype = UCD_CHARTYPE(c);
3910              if ((chartype == ucp_Lu ||              if ((chartype == ucp_Lu ||
3911                   chartype == ucp_Ll ||                   chartype == ucp_Ll ||
3912                   chartype == ucp_Lt) == prop_fail_result)                   chartype == ucp_Lt) == prop_fail_result)
3913                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3914              }              }
3915            break;            break;
3916    
# Line 3754  for (;;) Line 3920  for (;;)
3920              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3921                {                {
3922                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3923                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3924                }                }
3925              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3926              if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)              if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
3927                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3928              }              }
3929            break;            break;
3930    
# Line 3768  for (;;) Line 3934  for (;;)
3934              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3935                {                {
3936                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3937                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3938                }                }
3939              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3940              if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)              if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
3941                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3942              }              }
3943            break;            break;
3944    
# Line 3782  for (;;) Line 3948  for (;;)
3948              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3949                {                {
3950                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3951                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3952                }                }
3953              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3954              if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)              if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
3955                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3956              }              }
3957            break;            break;
3958    
# Line 3797  for (;;) Line 3963  for (;;)
3963              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3964                {                {
3965                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3966                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3967                }                }
3968              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3969              category = UCD_CATEGORY(c);              category = UCD_CATEGORY(c);
3970              if ((category == ucp_L || category == ucp_N) == prop_fail_result)              if ((category == ucp_L || category == ucp_N) == prop_fail_result)
3971                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3972              }              }
3973            break;            break;
3974    
# Line 3812  for (;;) Line 3978  for (;;)
3978              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3979                {                {
3980                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3981                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3982                }                }
3983              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
3984              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
3985                   c == CHAR_FF || c == CHAR_CR)                   c == CHAR_FF || c == CHAR_CR)
3986                     == prop_fail_result)                     == prop_fail_result)
3987                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3988              }              }
3989            break;            break;
3990    
# Line 3828  for (;;) Line 3994  for (;;)
3994              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
3995                {                {
3996                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3997                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3998                }                }
3999              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4000              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4001                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4002                     == prop_fail_result)                     == prop_fail_result)
4003                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4004              }              }
4005            break;            break;
4006    
# Line 3845  for (;;) Line 4011  for (;;)
4011              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4012                {                {
4013                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4014                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4015                }                }
4016              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4017              category = UCD_CATEGORY(c);              category = UCD_CATEGORY(c);
4018              if ((category == ucp_L || category == ucp_N || c == CHAR_UNDERSCORE)              if ((category == ucp_L || category == ucp_N || c == CHAR_UNDERSCORE)
4019                     == prop_fail_result)                     == prop_fail_result)
4020                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4021              }              }
4022            break;            break;
4023    
# Line 3872  for (;;) Line 4038  for (;;)
4038            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4039              {              {
4040              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4041              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4042              }              }
4043            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4044            if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);            if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);
4045            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4046              {              {
4047              int len = 1;              int len = 1;
# Line 3900  for (;;) Line 4066  for (;;)
4066            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4067              {              {
4068              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4069              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4070              }              }
4071            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4072            eptr++;            eptr++;
4073            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
4074            }            }
# Line 3914  for (;;) Line 4080  for (;;)
4080            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4081              {              {
4082              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4083              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4084              }              }
4085            eptr++;            eptr++;
4086            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
# Line 3922  for (;;) Line 4088  for (;;)
4088          break;          break;
4089    
4090          case OP_ANYBYTE:          case OP_ANYBYTE:
4091          if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH);          if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);
4092          eptr += min;          eptr += min;
4093          break;          break;
4094    
# Line 3932  for (;;) Line 4098  for (;;)
4098            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4099              {              {
4100              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4101              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4102              }              }
4103            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4104            switch(c)            switch(c)
4105              {              {
4106              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4107    
4108              case 0x000d:              case 0x000d:
4109              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
# Line 3951  for (;;) Line 4117  for (;;)
4117              case 0x0085:              case 0x0085:
4118              case 0x2028:              case 0x2028:
4119              case 0x2029:              case 0x2029:
4120              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4121              break;              break;
4122              }              }
4123            }            }
# Line 3963  for (;;) Line 4129  for (;;)
4129            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4130              {              {
4131              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4132              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4133              }              }
4134            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4135            switch(c)            switch(c)
# Line 3988  for (;;) Line 4154  for (;;)
4154              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
4155              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4156              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
4157              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4158              }              }
4159            }            }
4160          break;          break;
# Line 3999  for (;;) Line 4165  for (;;)
4165            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4166              {              {
4167              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4168              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4169              }              }
4170            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4171            switch(c)            switch(c)
4172              {              {
4173              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4174              case 0x09:      /* HT */              case 0x09:      /* HT */
4175              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4176              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 4035  for (;;) Line 4201  for (;;)
4201            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4202              {              {
4203              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4204              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4205              }              }
4206            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4207            switch(c)            switch(c)
# Line 4048  for (;;) Line 4214  for (;;)
4214              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4215              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
4216              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
4217              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4218              }              }
4219            }            }
4220          break;          break;
# Line 4059  for (;;) Line 4225  for (;;)
4225            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4226              {              {
4227              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4228              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4229              }              }
4230            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4231            switch(c)            switch(c)
4232              {              {
4233              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4234              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4235              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4236              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 4083  for (;;) Line 4249  for (;;)
4249            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4250              {              {
4251              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4252              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4253              }              }
4254            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4255            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)            if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
4256              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4257            }            }
4258          break;          break;
4259    
# Line 4097  for (;;) Line 4263  for (;;)
4263            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4264              {              {
4265              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4266              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4267              }              }
4268            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
4269              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4270            /* 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 */
4271            }            }
4272          break;          break;
# Line 4111  for (;;) Line 4277  for (;;)
4277            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4278              {              {
4279              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4280              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4281              }              }
4282            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)
4283              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4284            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
4285            }            }
4286          break;          break;
# Line 4125  for (;;) Line 4291  for (;;)
4291            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4292              {              {
4293              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4294              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4295              }              }
4296            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
4297              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4298            /* 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 */
4299            }            }
4300          break;          break;
# Line 4139  for (;;) Line 4305  for (;;)
4305            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4306              {              {
4307              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4308              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4309              }              }
4310            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)
4311              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4312            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
4313            }            }
4314          break;          break;
# Line 4153  for (;;) Line 4319  for (;;)
4319            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4320              {              {
4321              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4322              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4323              }              }
4324            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
4325              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4326            /* 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 */
4327            }            }
4328          break;          break;
# Line 4179  for (;;) Line 4345  for (;;)
4345            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4346              {              {
4347              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4348              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4349              }              }
4350            if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4351            eptr++;            eptr++;
4352            }            }
4353          break;          break;
# Line 4190  for (;;) Line 4356  for (;;)
4356          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
4357            {            {
4358            SCHECK_PARTIAL();            SCHECK_PARTIAL();
4359            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
4360            }            }
4361          eptr += min;          eptr += min;
4362          break;          break;
# Line 4199  for (;;) Line 4365  for (;;)
4365          if (eptr > md->end_subject - min)          if (eptr > md->end_subject - min)
4366            {            {
4367            SCHECK_PARTIAL();            SCHECK_PARTIAL();
4368            MRRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
4369            }            }
4370          eptr += min;          eptr += min;
4371          break;          break;
# Line 4210  for (;;) Line 4376  for (;;)
4376            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4377              {              {
4378              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4379              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4380              }              }
4381            switch(*eptr++)            switch(*eptr++)
4382              {              {
4383              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4384    
4385              case 0x000d:              case 0x000d:
4386              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
# Line 4226  for (;;) Line 4392  for (;;)
4392              case 0x000b:              case 0x000b:
4393              case 0x000c:              case 0x000c:
4394              case 0x0085:              case 0x0085:
4395              if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4396              break;              break;
4397              }              }
4398            }            }
# Line 4238  for (;;) Line 4404  for (;;)
4404            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4405              {              {
4406              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4407              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4408              }              }
4409            switch(*eptr++)            switch(*eptr++)
4410              {              {
# Line 4246  for (;;) Line 4412  for (;;)
4412              case 0x09:      /* HT */              case 0x09:      /* HT */
4413              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4414              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4415              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4416              }              }
4417            }            }
4418          break;          break;
# Line 4257  for (;;) Line 4423  for (;;)
4423            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4424              {              {
4425              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4426              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4427              }              }
4428            switch(*eptr++)            switch(*eptr++)
4429              {              {
4430              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4431              case 0x09:      /* HT */              case 0x09:      /* HT */
4432              case 0x20:      /* SPACE */              case 0x20:      /* SPACE */
4433              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
# Line 4276  for (;;) Line 4442  for (;;)
4442            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4443              {              {
4444              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4445              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4446              }              }
4447            switch(*eptr++)            switch(*eptr++)
4448              {              {
# Line 4286  for (;;) Line 4452  for (;;)
4452              case 0x0c:      /* FF */              case 0x0c:      /* FF */
4453              case 0x0d:      /* CR */              case 0x0d:      /* CR */
4454              case 0x85:      /* NEL */              case 0x85:      /* NEL */
4455              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4456              }              }
4457            }            }
4458          break;          break;
# Line 4297  for (;;) Line 4463  for (;;)
4463            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4464              {              {
4465              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4466              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4467              }              }
4468            switch(*eptr++)            switch(*eptr++)
4469              {              {
4470              default: MRRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4471              case 0x0a:      /* LF */              case 0x0a:      /* LF */
4472              case 0x0b:      /* VT */              case 0x0b:      /* VT */
4473              case 0x0c:      /* FF */              case 0x0c:      /* FF */
# Line 4318  for (;;) Line 4484  for (;;)
4484            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4485              {              {
4486              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4487              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4488              }              }
4489            if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
4490            }            }
4491          break;          break;
4492    
# Line 4330  for (;;) Line 4496  for (;;)
4496            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4497              {              {
4498              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4499              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4500              }              }
4501            if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
4502            }            }
4503          break;          break;
4504    
# Line 4342  for (;;) Line 4508  for (;;)
4508            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4509              {              {
4510              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4511              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4512              }              }
4513            if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
4514            }            }
4515          break;          break;
4516    
# Line 4354  for (;;) Line 4520  for (;;)
4520            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4521              {              {
4522              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4523              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4524              }              }
4525            if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
4526            }            }
4527          break;          break;
4528    
# Line 4366  for (;;) Line 4532  for (;;)
4532            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4533              {              {
4534              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4535              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4536              }              }
4537            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if ((md->ctypes[*eptr++] & ctype_word) != 0)
4538              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4539            }            }
4540          break;          break;
4541    
# Line 4379  for (;;) Line 4545  for (;;)
4545            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4546              {              {
4547              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4548              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4549              }              }
4550            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if ((md->ctypes[*eptr++] & ctype_word) == 0)
4551              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4552            }            }
4553          break;          break;
4554    
# Line 4411  for (;;) Line 4577  for (;;)
4577              {              {
4578              RMATCH(eptr, ecode, offset_top, md, eptrb, RM36);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM36);
4579              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4580              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4581              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4582                {                {
4583                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4584                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4585                }                }
4586              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4587              if (prop_fail_result) MRRETURN(MATCH_NOMATCH);              if (prop_fail_result) RRETURN(MATCH_NOMATCH);
4588              }              }
4589            /* Control never gets here */            /* Control never gets here */
4590    
# Line 4428  for (;;) Line 4594  for (;;)
4594              int chartype;              int chartype;
4595              RMATCH(eptr, ecode, offset_top, md, eptrb, RM37);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM37);
4596              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4597              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4598              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4599                {                {
4600                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4601                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4602                }                }
4603              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4604              chartype = UCD_CHARTYPE(c);              chartype = UCD_CHARTYPE(c);
4605              if ((chartype == ucp_Lu ||              if ((chartype == ucp_Lu ||
4606                   chartype == ucp_Ll ||                   chartype == ucp_Ll ||
4607                   chartype == ucp_Lt) == prop_fail_result)                   chartype == ucp_Lt) == prop_fail_result)
4608                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4609              }              }
4610            /* Control never gets here */            /* Control never gets here */
4611    
# Line 4448  for (;;) Line 4614  for (;;)
4614              {              {
4615              RMATCH(eptr, ecode, offset_top, md, eptrb, RM38);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM38);
4616              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4617              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4618              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4619                {                {
4620                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4621                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4622                }                }
4623              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4624              if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)              if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
4625                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4626              }              }
4627            /* Control never gets here */            /* Control never gets here */
4628    
# Line 4465  for (;;) Line 4631  for (;;)
4631              {              {
4632              RMATCH(eptr, ecode, offset_top, md, eptrb, RM39);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM39);
4633              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4634              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4635              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4636                {                {
4637                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4638                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4639                }                }
4640              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4641              if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)              if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
4642                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4643              }              }
4644            /* Control never gets here */            /* Control never gets here */
4645    
# Line 4482  for (;;) Line 4648  for (;;)
4648              {              {
4649              RMATCH(eptr, ecode, offset_top, md, eptrb, RM40);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM40);
4650              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4651              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4652              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4653                {                {
4654                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4655                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4656                }                }
4657              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4658              if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)              if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
4659                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4660              }              }
4661            /* Control never gets here */            /* Control never gets here */
4662    
# Line 4500  for (;;) Line 4666  for (;;)
4666              int category;              int category;
4667              RMATCH(eptr, ecode, offset_top, md, eptrb, RM59);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM59);
4668              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4669              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4670              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4671                {                {
4672                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4673                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4674                }                }
4675              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4676              category = UCD_CATEGORY(c);              category = UCD_CATEGORY(c);
4677              if ((category == ucp_L || category == ucp_N) == prop_fail_result)              if ((category == ucp_L || category == ucp_N) == prop_fail_result)
4678                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4679              }              }
4680            /* Control never gets here */            /* Control never gets here */
4681    
# Line 4518  for (;;) Line 4684  for (;;)
4684              {              {
4685              RMATCH(eptr, ecode, offset_top, md, eptrb, RM60);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM60);
4686              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4687              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4688              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4689                {                {
4690                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4691                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4692                }                }
4693              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4694              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4695                   c == CHAR_FF || c == CHAR_CR)                   c == CHAR_FF || c == CHAR_CR)
4696                     == prop_fail_result)                     == prop_fail_result)
4697                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4698              }              }
4699            /* Control never gets here */            /* Control never gets here */
4700    
# Line 4537  for (;;) Line 4703  for (;;)
4703              {              {
4704              RMATCH(eptr, ecode, offset_top, md, eptrb, RM61);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM61);
4705              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4706              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4707              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4708                {                {
4709                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4710                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4711                }                }
4712              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4713              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||              if ((UCD_CATEGORY(c) == ucp_Z || c == CHAR_HT || c == CHAR_NL ||
4714                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)                   c == CHAR_VT || c == CHAR_FF || c == CHAR_CR)
4715                     == prop_fail_result)                     == prop_fail_result)
4716                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4717              }              }
4718            /* Control never gets here */            /* Control never gets here */
4719    
# Line 4557  for (;;) Line 4723  for (;;)
4723              int category;              int category;
4724              RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);
4725              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4726              if (fi >= max) MRRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
4727              if (eptr >= md->end_subject)              if (eptr >= md->end_subject)
4728                {                {
4729                SCHECK_PARTIAL();                SCHECK_PARTIAL();
4730                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4731                }                }
4732              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
4733              category = UCD_CATEGORY(c);              category = UCD_CATEGORY(c);
# Line 4569  for (;;) Line 4735  for (;;)
4735                   category == ucp_N ||                   category == ucp_N ||
4736                   c == CHAR_UNDERSCORE)                   c == CHAR_UNDERSCORE)
4737                     == prop_fail_result)                     == prop_fail_result)
4738                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4739              }              }
4740            /* Control never gets here */            /* Control never gets here */
4741    
# Line 4589  for (;;) Line 4755  for (;;)
4755            {            {
4756            RMATCH(eptr, ecode, offset_top, md, eptrb, RM41);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM41);
4757            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4758            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
4759            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4760              {              {
4761              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4762              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4763              }              }
4764            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
4765            if (UCD_CATEGORY(c) == ucp_M) MRRETURN(MATCH_NOMATCH);            if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);
4766            while (eptr < md->end_subject)            while (eptr < md->end_subject)
4767              {              {
4768              int len = 1;              int len = 1;
# Line 4617  for (;;) Line 4783  for (;;)
4783            {            {
4784            RMATCH(eptr, ecode, offset_top, md, eptrb, RM42);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM42);
4785            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4786            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
4787            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4788              {              {
4789              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4790              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4791              }              }
4792            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4793              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4794            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4795            switch(ctype)            switch(ctype)
4796              {              {
# Line 4636  for (;;) Line 4802  for (;;)
4802              case OP_ANYNL:              case OP_ANYNL:
4803              switch(c)              switch(c)
4804                {                {
4805                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4806                case 0x000d:                case 0x000d:
4807                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4808                break;                break;
# Line 4648  for (;;) Line 4814  for (;;)
4814                case 0x0085:                case 0x0085:
4815                case 0x2028:                case 0x2028:
4816                case 0x2029:                case 0x2029:
4817                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4818                break;                break;
4819                }                }
4820              break;              break;
# Line 4676  for (;;) Line 4842  for (;;)
4842                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
4843                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4844                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
4845                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4846                }                }
4847              break;              break;
4848    
4849              case OP_HSPACE:              case OP_HSPACE:
4850              switch(c)              switch(c)
4851                {                {
4852                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4853                case 0x09:      /* HT */                case 0x09:      /* HT */
4854                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4855                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4718  for (;;) Line 4884  for (;;)
4884                case 0x85:      /* NEL */                case 0x85:      /* NEL */
4885                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
4886                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
4887                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4888                }                }
4889              break;              break;
4890    
4891              case OP_VSPACE:              case OP_VSPACE:
4892              switch(c)              switch(c)
4893                {                {
4894                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4895                case 0x0a:      /* LF */                case 0x0a:      /* LF */
4896                case 0x0b:      /* VT */                case 0x0b:      /* VT */
4897                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4739  for (;;) Line 4905  for (;;)
4905    
4906              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
4907              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)              if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
4908                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4909              break;              break;
4910    
4911              case OP_DIGIT:              case OP_DIGIT:
4912              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
4913                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4914              break;              break;
4915    
4916              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
4917              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)              if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
4918                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4919              break;              break;
4920    
4921              case OP_WHITESPACE:              case OP_WHITESPACE:
4922              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
4923                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4924              break;              break;
4925    
4926              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
4927              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)              if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
4928                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4929              break;              break;
4930    
4931              case OP_WORDCHAR:              case OP_WORDCHAR:
4932              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
4933                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4934              break;              break;
4935    
4936              default:              default:
# Line 4780  for (;;) Line 4946  for (;;)
4946            {            {
4947            RMATCH(eptr, ecode, offset_top, md, eptrb, RM43);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM43);
4948            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4949            if (fi >= max) MRRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
4950            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4951              {              {
4952              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4953              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4954              }              }
4955            if (ctype == OP_ANY && IS_NEWLINE(eptr))            if (ctype == OP_ANY && IS_NEWLINE(eptr))
4956              MRRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4957            c = *eptr++;            c = *eptr++;
4958            switch(ctype)            switch(ctype)
4959              {              {
# Line 4799  for (;;) Line 4965  for (;;)
4965              case OP_ANYNL:              case OP_ANYNL:
4966              switch(c)              switch(c)
4967                {                {
4968                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4969                case 0x000d:                case 0x000d:
4970                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
4971                break;                break;
# Line 4810  for (;;) Line 4976  for (;;)
4976                case 0x000b:                case 0x000b:
4977                case 0x000c:                case 0x000c:
4978                case 0x0085:                case 0x0085:
4979                if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4980                break;                break;
4981                }                }
4982              break;              break;
# Line 4822  for (;;) Line 4988  for (;;)
4988                case 0x09:      /* HT */                case 0x09:      /* HT */
4989                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
4990                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
4991                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4992                }                }
4993              break;              break;
4994    
4995              case OP_HSPACE:              case OP_HSPACE:
4996              switch(c)              switch(c)
4997                {                {
4998                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4999                case 0x09:      /* HT */                case 0x09:      /* HT */
5000                case 0x20:      /* SPACE */                case 0x20:      /* SPACE */
5001                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
# Line 4846  for (;;) Line 5012  for (;;)
5012                case 0x0c:      /* FF */                case 0x0c:      /* FF */
5013                case 0x0d:      /* CR */                case 0x0d:      /* CR */
5014                case 0x85:      /* NEL */                case 0x85:      /* NEL */
5015                MRRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5016                }                }
5017              break;              break;
5018    
5019              case OP_VSPACE:              case OP_VSPACE:
5020              switch(c)              switch(c)
5021                {                {
5022                default: MRRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5023                case 0x0a:      /* LF */                case 0x0a:      /* LF */
5024                case 0x0b:      /* VT */                case 0x0b:      /* VT */
5025                case 0x0c:      /* FF */                case 0x0c:      /* FF */
# Line 4864  for (;;) Line 5030  for (;;)
5030              break;              break;
5031    
5032              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
5033              if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
5034              break;              break;
5035    
5036              case OP_DIGIT:              case OP_DIGIT:
5037              if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
5038              break;              break;
5039    
5040              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
5041              if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
5042              break;              break;
5043    
5044              case OP_WHITESPACE:              case OP_WHITESPACE:
5045              if  ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH);              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
5046              break;              break;
5047    
5048              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
5049              if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
5050              break;              break;
5051    
5052              case OP_WORDCHAR:              case OP_WORDCHAR:
5053              if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH);              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
5054              break;              break;
5055    
5056              default:              default:
# Line 5182  for (;;) Line 5348  for (;;)
5348                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
5349                }                }
5350              }              }
5351            else eptr = md->end_subject;   /* Unlimited UTF-8 repeat */            else
5352                {
5353                eptr = md->end_subject;   /* Unlimited UTF-8 repeat */
5354                SCHECK_PARTIAL();
5355                }
5356            break;            break;
5357    
5358            /* The byte case is the same as non-UTF8 */            /* The byte case is the same as non-UTF8 */
# Line 5622  for (;;) Line 5792  for (;;)
5792    
5793        /* 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 */
5794    
5795        MRRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
5796        }        }
5797      /* Control never gets here */      /* Control never gets here */
5798    
# Line 5655  switch (frame->Xwhere) Line 5825  switch (frame->Xwhere)
5825    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)
5826    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)
5827    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)
5828    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58) LBL(63)    LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58) LBL(63) LBL(64)
5829      LBL(65) LBL(66)
5830  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
5831    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)
5832    LBL(32) LBL(34) LBL(42) LBL(46)    LBL(32) LBL(34) LBL(42) LBL(46)
# Line 5757  pcre_exec(const pcre *argument_re, const Line 5928  pcre_exec(const pcre *argument_re, const
5928    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
5929    int offsetcount)    int offsetcount)
5930  {  {
5931  int rc, ocount;  int rc, ocount, arg_offset_max;
5932  int first_byte = -1;  int first_byte = -1;
5933  int req_byte = -1;  int req_byte = -1;
5934  int req_byte2 = -1;  int req_byte2 = -1;
# Line 5793  if (re == NULL || subject == NULL || Line 5964  if (re == NULL || subject == NULL ||
5964  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
5965  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
5966    
5967  /* This information is for finding all the numbers associated with a given  /* These two settings are used in the code for checking a UTF-8 string that
5968  name, for condition testing. */  follows immediately afterwards. Other values in the md block are used only
5969    during "normal" pcre_exec() processing, not when the JIT support is in use,
5970    so they are set up later. */
5971    
5972    utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
5973    md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
5974                  ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
5975    
5976    /* Check a UTF-8 string if required. Pass back the character offset and error
5977    code for an invalid string if a results vector is available. */
5978    
5979    #ifdef SUPPORT_UTF8
5980    if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
5981      {
5982      int erroroffset;
5983      int errorcode = _pcre_valid_utf8((USPTR)subject, length, &erroroffset);
5984      if (errorcode != 0)
5985        {
5986        if (offsetcount >= 2)
5987          {
5988          offsets[0] = erroroffset;
5989          offsets[1] = errorcode;
5990          }
5991        return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?
5992          PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
5993        }
5994    
5995      /* Check that a start_offset points to the start of a UTF-8 character. */
5996      if (start_offset > 0 && start_offset < length &&
5997          (((USPTR)subject)[start_offset] & 0xc0) == 0x80)
5998        return PCRE_ERROR_BADUTF8_OFFSET;
5999      }
6000    #endif
6001    
6002    /* If the pattern was successfully studied with JIT support, run the JIT
6003    executable instead of the rest of this function. Most options must be set at
6004    compile time for the JIT code to be usable. Fallback to the normal code path if
6005    an unsupported flag is set. In particular, JIT does not support partial
6006    matching. */
6007    
6008    #ifdef SUPPORT_JIT
6009    if (extra_data != NULL
6010        && (extra_data->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0
6011        && extra_data->executable_jit != NULL
6012        && (extra_data->flags & PCRE_EXTRA_TABLES) == 0
6013        && (options & ~(PCRE_NO_UTF8_CHECK | PCRE_NOTBOL | PCRE_NOTEOL |
6014                        PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART)) == 0)
6015      return _pcre_jit_exec(re, extra_data->executable_jit, subject, length,
6016        start_offset, options, ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)
6017        ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);
6018    #endif
6019    
6020    /* Carry on with non-JIT matching. This information is for finding all the
6021    numbers associated with a given name, for condition testing. */
6022    
6023  md->name_table = (uschar *)re + re->name_table_offset;  md->name_table = (uschar *)re + re->name_table_offset;
6024  md->name_count = re->name_count;  md->name_count = re->name_count;
# Line 5861  md->end_subject = md->start_subject + le Line 6085  md->end_subject = md->start_subject + le
6085  end_subject = md->end_subject;  end_subject = md->end_subject;
6086    
6087  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
 utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;  
6088  md->use_ucp = (re->options & PCRE_UCP) != 0;  md->use_ucp = (re->options & PCRE_UCP) != 0;
6089  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;  md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
6090    md->ignore_skip_arg = FALSE;
6091    
6092  /* Some options are unpacked into BOOL variables in the hope that testing  /* Some options are unpacked into BOOL variables in the hope that testing
6093  them will be faster than individual option bits. */  them will be faster than individual option bits. */
# Line 5872  md->notbol = (options & PCRE_NOTBOL) != Line 6096  md->notbol = (options & PCRE_NOTBOL) !=
6096  md->noteol = (options & PCRE_NOTEOL) != 0;  md->noteol = (options & PCRE_NOTEOL) != 0;
6097  md->notempty = (options & PCRE_NOTEMPTY) != 0;  md->notempty = (options & PCRE_NOTEMPTY) != 0;
6098  md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;  md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
 md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :  
               ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;  
   
6099    
6100  md->hitend = FALSE;  md->hitend = FALSE;
6101  md->mark = NULL;                        /* In case never set */  md->mark = md->nomatch_mark = NULL;     /* In case never set */
6102    
6103  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
6104    md->hasthen = (re->flags & PCRE_HASTHEN) != 0;
6105    
6106  md->lcc = tables + lcc_offset;  md->lcc = tables + lcc_offset;
6107  md->ctypes = tables + ctypes_offset;  md->ctypes = tables + ctypes_offset;
# Line 5957  defined (though never set). So there's n Line 6179  defined (though never set). So there's n
6179  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
6180    return PCRE_ERROR_BADPARTIAL;    return PCRE_ERROR_BADPARTIAL;
6181    
 /* Check a UTF-8 string if required. Pass back the character offset and error  
 code for an invalid string if a results vector is available. */  
   
 #ifdef SUPPORT_UTF8  
 if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)  
   {  
   int erroroffset;  
   int errorcode = _pcre_valid_utf8((USPTR)subject, length, &erroroffset);  
   if (errorcode != 0)  
     {  
     if (offsetcount >= 2)  
       {  
       offsets[0] = erroroffset;  
       offsets[1] = errorcode;  
       }  
     return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?  
       PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;  
     }  
   
   /* Check that a start_offset points to the start of a UTF-8 character. */  
   
   if (start_offset > 0 && start_offset < length &&  
       (((USPTR)subject)[start_offset] & 0xc0) == 0x80)  
     return PCRE_ERROR_BADUTF8_OFFSET;  
   }  
 #endif  
   
6182  /* If the expression has got more back references than the offsets supplied can  /* If the expression has got more back references than the offsets supplied can
6183  hold, we get a temporary chunk of working store to use during the matching.  hold, we get a temporary chunk of working store to use during the matching.
6184  Otherwise, we can use the vector supplied, rounding down its size to a multiple  Otherwise, we can use the vector supplied, rounding down its size to a multiple
6185  of 3. */  of 3. */
6186    
6187  ocount = offsetcount - (offsetcount % 3);  ocount = offsetcount - (offsetcount % 3);
6188    arg_offset_max = (2*ocount)/3;
6189    
6190  if (re->top_backref > 0 && re->top_backref >= ocount/3)  if (re->top_backref > 0 && re->top_backref >= ocount/3)
6191    {    {
# Line 6169  for(;;) Line 6365  for(;;)
6365    /* The following two optimizations are disabled for partial matching or if    /* The following two optimizations are disabled for partial matching or if
6366    disabling is explicitly requested. */    disabling is explicitly requested. */
6367    
6368    if ((options & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)    if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)
6369      {      {
6370      /* 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
6371      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
# Line 6254  for(;;) Line 6450  for(;;)
6450    md->match_call_count = 0;    md->match_call_count = 0;
6451    md->match_function_type = 0;    md->match_function_type = 0;
6452    md->end_offset_top = 0;    md->end_offset_top = 0;
6453    rc = match(start_match, md->start_code, start_match, NULL, 2, md, NULL, 0);    rc = match(start_match, md->start_code, start_match, 2, md, NULL, 0);
6454    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;    if (md->hitend && start_partial == NULL) start_partial = md->start_used_ptr;
6455    
6456    switch(rc)    switch(rc)
6457      {      {
6458        /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched
6459        the SKIP's arg was not found. In this circumstance, Perl ignores the SKIP
6460        entirely. The only way we can do that is to re-do the match at the same
6461        point, with a flag to force SKIP with an argument to be ignored. Just
6462        treating this case as NOMATCH does not work because it does not check other
6463        alternatives in patterns such as A(*SKIP:A)B|AC when the subject is AC. */
6464    
6465        case MATCH_SKIP_ARG:
6466        new_start_match = start_match;
6467        md->ignore_skip_arg = TRUE;
6468        break;
6469    
6470      /* SKIP passes back the next starting point explicitly, but if it is the      /* SKIP passes back the next starting point explicitly, but if it is the
6471      same as the match we have just done, treat it as NOMATCH. */      same as the match we have just done, treat it as NOMATCH. */
6472    
# Line 6270  for(;;) Line 6478  for(;;)
6478        }        }
6479      /* Fall through */      /* Fall through */
6480    
     /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched  
     the SKIP's arg was not found. We also treat this as NOMATCH. */  
   
     case MATCH_SKIP_ARG:  
     /* Fall through */  
   
6481      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. THEN at this level acts
6482      exactly like PRUNE. */      exactly like PRUNE. Unset the ignore SKIP-with-argument flag. */
6483    
6484      case MATCH_NOMATCH:      case MATCH_NOMATCH:
6485      case MATCH_PRUNE:      case MATCH_PRUNE:
6486      case MATCH_THEN:      case MATCH_THEN:
6487        md->ignore_skip_arg = FALSE;
6488      new_start_match = start_match + 1;      new_start_match = start_match + 1;
6489  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
6490      if (utf8)      if (utf8)
# Line 6364  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6567  if (rc == MATCH_MATCH || rc == MATCH_ACC
6567    {    {
6568    if (using_temporary_offsets)    if (using_temporary_offsets)
6569      {      {
6570      if (offsetcount >= 4)      if (arg_offset_max >= 4)
6571        {        {
6572        memcpy(offsets + 2, md->offset_vector + 2,        memcpy(offsets + 2, md->offset_vector + 2,
6573          (offsetcount - 2) * sizeof(int));          (arg_offset_max - 2) * sizeof(int));
6574        DPRINTF(("Copied offsets from temporary memory\n"));        DPRINTF(("Copied offsets from temporary memory\n"));
6575        }        }
6576      if (md->end_offset_top > offsetcount) md->offset_overflow = TRUE;      if (md->end_offset_top > arg_offset_max) md->offset_overflow = TRUE;
6577      DPRINTF(("Freeing temporary memory\n"));      DPRINTF(("Freeing temporary memory\n"));
6578      (pcre_free)(md->offset_vector);      (pcre_free)(md->offset_vector);
6579      }      }
6580    
6581    /* Set the return code to the number of captured strings, or 0 if there are    /* Set the return code to the number of captured strings, or 0 if there were
6582    too many to fit into the vector. */    too many to fit into the vector. */
6583    
6584    rc = md->offset_overflow? 0 : md->end_offset_top/2;    rc = (md->offset_overflow && md->end_offset_top >= arg_offset_max)?
6585        0 : md->end_offset_top/2;
6586    
6587    /* If there is space in the offset vector, set any unused pairs at the end of    /* If there is space in the offset vector, set any unused pairs at the end of
6588    the pattern to -1 for backwards compatibility. It is documented that this    the pattern to -1 for backwards compatibility. It is documented that this
6589    happens. In earlier versions, the whole set of potential capturing offsets    happens. In earlier versions, the whole set of potential capturing offsets
6590    was set to -1 each time round the loop, but this is handled differently now.    was set to -1 each time round the loop, but this is handled differently now.
6591    "Gaps" are set to -1 dynamically instead (this fixes a bug). Thus, it is only    "Gaps" are set to -1 dynamically instead (this fixes a bug). Thus, it is only
6592    those at the end that need unsetting here. We can't just unset them all at    those at the end that need unsetting here. We can't just unset them all at
6593    the start of the whole thing because they may get set in one branch that is    the start of the whole thing because they may get set in one branch that is
6594    not the final matching branch. */    not the final matching branch. */
# Line 6409  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6613  if (rc == MATCH_MATCH || rc == MATCH_ACC
6613      offsets[1] = (int)(md->end_match_ptr - md->start_subject);      offsets[1] = (int)(md->end_match_ptr - md->start_subject);
6614      }      }
6615    
6616      /* Return MARK data if requested */
6617    
6618      if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6619        *(extra_data->mark) = (unsigned char *)(md->mark);
6620    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
6621    goto RETURN_MARK;    return rc;
6622    }    }
6623    
6624  /* Control gets here if there has been an error, or if the overall match  /* Control gets here if there has been an error, or if the overall match
# Line 6454  else Line 6662  else
6662    
6663  /* Return the MARK data if it has been requested. */  /* Return the MARK data if it has been requested. */
6664    
 RETURN_MARK:  
   
6665  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6666    *(extra_data->mark) = (unsigned char *)(md->mark);    *(extra_data->mark) = (unsigned char *)(md->nomatch_mark);
6667  return rc;  return rc;
6668  }  }
6669    
Legend:
Removed from v.648  
changed lines
  Added in v.771
webmaster@exim.org
 ViewVC Help
Powered by ViewVC 1.1.12