/[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 165 by ph10, Wed May 9 10:50:57 2007 UTC revision 392 by ph10, Tue Mar 17 21:30:30 2009 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                         Written by Philip Hazel                         Written by Philip Hazel
9             Copyright (c) 1997-2007 University of Cambridge             Copyright (c) 1997-2009 University of Cambridge
10    
11  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
12  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# Line 42  POSSIBILITY OF SUCH DAMAGE. Line 42  POSSIBILITY OF SUCH DAMAGE.
42  pattern matching using an NFA algorithm, trying to mimic Perl as closely as  pattern matching using an NFA algorithm, trying to mimic Perl as closely as
43  possible. There are also some static supporting functions. */  possible. There are also some static supporting functions. */
44    
45    #ifdef HAVE_CONFIG_H
46    #include "config.h"
47    #endif
48    
49  #define NLBLOCK md             /* Block containing newline information */  #define NLBLOCK md             /* Block containing newline information */
50  #define PSSTART start_subject  /* Field containing processed string start */  #define PSSTART start_subject  /* Field containing processed string start */
51  #define PSEND   end_subject    /* Field containing processed string end */  #define PSEND   end_subject    /* Field containing processed string end */
# Line 53  possible. There are also some static sup Line 57  possible. There are also some static sup
57  #undef min  #undef min
58  #undef max  #undef max
59    
 /* The chain of eptrblocks for tail recursions uses memory in stack workspace,  
 obtained at top level, the size of which is defined by EPTR_WORK_SIZE. */  
   
 #define EPTR_WORK_SIZE (1000)  
   
60  /* Flag bits for the match() function */  /* Flag bits for the match() function */
61    
62  #define match_condassert     0x01  /* Called to check a condition assertion */  #define match_condassert     0x01  /* Called to check a condition assertion */
63  #define match_cbegroup       0x02  /* Could-be-empty unlimited repeat group */  #define match_cbegroup       0x02  /* Could-be-empty unlimited repeat group */
 #define match_tail_recursed  0x04  /* Tail recursive call */  
64    
65  /* Non-error returns from the match() function. Error returns are externally  /* Non-error returns from the match() function. Error returns are externally
66  defined PCRE_ERROR_xxx codes, which are all negative. */  defined PCRE_ERROR_xxx codes, which are all negative. */
# Line 70  defined PCRE_ERROR_xxx codes, which are Line 68  defined PCRE_ERROR_xxx codes, which are
68  #define MATCH_MATCH        1  #define MATCH_MATCH        1
69  #define MATCH_NOMATCH      0  #define MATCH_NOMATCH      0
70    
71    /* Special internal returns from the match() function. Make them sufficiently
72    negative to avoid the external error codes. */
73    
74    #define MATCH_COMMIT       (-999)
75    #define MATCH_PRUNE        (-998)
76    #define MATCH_SKIP         (-997)
77    #define MATCH_THEN         (-996)
78    
79  /* 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.
80  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,
81  because the offset vector is always a multiple of 3 long. */  because the offset vector is always a multiple of 3 long. */
# Line 152  printf("\n"); Line 158  printf("\n");
158    
159  if (length > md->end_subject - eptr) return FALSE;  if (length > md->end_subject - eptr) return FALSE;
160    
161  /* Separate the caselesss case for speed */  /* Separate the caseless case for speed. In UTF-8 mode we can only do this
162    properly if Unicode properties are supported. Otherwise, we can check only
163    ASCII characters. */
164    
165  if ((ims & PCRE_CASELESS) != 0)  if ((ims & PCRE_CASELESS) != 0)
166    {    {
167    #ifdef SUPPORT_UTF8
168    #ifdef SUPPORT_UCP
169      if (md->utf8)
170        {
171        USPTR endptr = eptr + length;
172        while (eptr < endptr)
173          {
174          int c, d;
175          GETCHARINC(c, eptr);
176          GETCHARINC(d, p);
177          if (c != d && c != UCD_OTHERCASE(d)) return FALSE;
178          }
179        }
180      else
181    #endif
182    #endif
183    
184      /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
185      is no UCP support. */
186    
187    while (length-- > 0)    while (length-- > 0)
188      if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE;      { if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE; }
189    }    }
190    
191    /* In the caseful case, we can just compare the bytes, whether or not we
192    are in UTF-8 mode. */
193    
194  else  else
195    { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }    { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
196    
# Line 205  variable instead of being passed in the Line 237  variable instead of being passed in the
237  ****************************************************************************  ****************************************************************************
238  ***************************************************************************/  ***************************************************************************/
239    
240    /* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
241  /* Numbers for RMATCH calls */  below must be updated in sync.  */
242    
243  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,
244         RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,         RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
245         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
246         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
247         RM41,  RM42, RM43, RM44, RM45, RM46, RM47 };         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
248           RM51,  RM52, RM53, RM54 };
249    
250  /* 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
251  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 226  actuall used in this definition. */ Line 258  actuall used in this definition. */
258  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
259    { \    { \
260    printf("match() called in line %d\n", __LINE__); \    printf("match() called in line %d\n", __LINE__); \
261    rrc = match(ra,rb,rc,rd,re,rf,rg,rdepth+1); \    rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1); \
262    printf("to line %d\n", __LINE__); \    printf("to line %d\n", __LINE__); \
263    }    }
264  #define RRETURN(ra) \  #define RRETURN(ra) \
# Line 236  actuall used in this definition. */ Line 268  actuall used in this definition. */
268    }    }
269  #else  #else
270  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \  #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \
271    rrc = match(ra,rb,rc,rd,re,rf,rg,rdepth+1)    rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1)
272  #define RRETURN(ra) return ra  #define RRETURN(ra) return ra
273  #endif  #endif
274    
# Line 255  argument of match(), which never changes Line 287  argument of match(), which never changes
287    frame->Xwhere = rw; \    frame->Xwhere = rw; \
288    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
289    newframe->Xecode = rb;\    newframe->Xecode = rb;\
290      newframe->Xmstart = mstart;\
291    newframe->Xoffset_top = rc;\    newframe->Xoffset_top = rc;\
292    newframe->Xims = re;\    newframe->Xims = re;\
293    newframe->Xeptrb = rf;\    newframe->Xeptrb = rf;\
# Line 291  typedef struct heapframe { Line 324  typedef struct heapframe {
324    
325    const uschar *Xeptr;    const uschar *Xeptr;
326    const uschar *Xecode;    const uschar *Xecode;
327      const uschar *Xmstart;
328    int Xoffset_top;    int Xoffset_top;
329    long int Xims;    long int Xims;
330    eptrblock *Xeptrb;    eptrblock *Xeptrb;
# Line 371  made performance worse. Line 405  made performance worse.
405  Arguments:  Arguments:
406     eptr        pointer to current character in subject     eptr        pointer to current character in subject
407     ecode       pointer to current position in compiled code     ecode       pointer to current position in compiled code
408       mstart      pointer to the current match start position (can be modified
409                     by encountering \K)
410     offset_top  current top pointer     offset_top  current top pointer
411     md          pointer to "static" info for the match     md          pointer to "static" info for the match
412     ims         current /i, /m, and /s options     ims         current /i, /m, and /s options
# Line 380  Arguments: Line 416  Arguments:
416                   match_condassert - this is an assertion condition                   match_condassert - this is an assertion condition
417                   match_cbegroup - this is the start of an unlimited repeat                   match_cbegroup - this is the start of an unlimited repeat
418                     group that can match an empty string                     group that can match an empty string
                  match_tail_recursed - this is a tail_recursed group  
419     rdepth      the recursion depth     rdepth      the recursion depth
420    
421  Returns:       MATCH_MATCH if matched            )  these values are >= 0  Returns:       MATCH_MATCH if matched            )  these values are >= 0
# Line 390  Returns:       MATCH_MATCH if matched Line 425  Returns:       MATCH_MATCH if matched
425  */  */
426    
427  static int  static int
428  match(REGISTER USPTR eptr, REGISTER const uschar *ecode,  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, const uschar *mstart,
429    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,    int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
430    int flags, unsigned int rdepth)    int flags, unsigned int rdepth)
431  {  {
# Line 418  frame->Xprevframe = NULL;            /* Line 453  frame->Xprevframe = NULL;            /*
453    
454  frame->Xeptr = eptr;  frame->Xeptr = eptr;
455  frame->Xecode = ecode;  frame->Xecode = ecode;
456    frame->Xmstart = mstart;
457  frame->Xoffset_top = offset_top;  frame->Xoffset_top = offset_top;
458  frame->Xims = ims;  frame->Xims = ims;
459  frame->Xeptrb = eptrb;  frame->Xeptrb = eptrb;
# Line 432  HEAP_RECURSE: Line 468  HEAP_RECURSE:
468    
469  #define eptr               frame->Xeptr  #define eptr               frame->Xeptr
470  #define ecode              frame->Xecode  #define ecode              frame->Xecode
471    #define mstart             frame->Xmstart
472  #define offset_top         frame->Xoffset_top  #define offset_top         frame->Xoffset_top
473  #define ims                frame->Xims  #define ims                frame->Xims
474  #define eptrb              frame->Xeptrb  #define eptrb              frame->Xeptrb
# Line 580  original_ims = ims;    /* Save for reset Line 617  original_ims = ims;    /* Save for reset
617  string, the match_cbegroup flag is set. When this is the case, add the current  string, the match_cbegroup flag is set. When this is the case, add the current
618  subject pointer to the chain of such remembered pointers, to be checked when we  subject pointer to the chain of such remembered pointers, to be checked when we
619  hit the closing ket, in order to break infinite loops that match no characters.  hit the closing ket, in order to break infinite loops that match no characters.
620  When match() is called in other circumstances, don't add to the chain. If this  When match() is called in other circumstances, don't add to the chain. The
621  is a tail recursion, use a block from the workspace, as the one on the stack is  match_cbegroup flag must NOT be used with tail recursion, because the memory
622  already used. */  block that is used is on the stack, so a new one may be required for each
623    match(). */
624    
625  if ((flags & match_cbegroup) != 0)  if ((flags & match_cbegroup) != 0)
626    {    {
627    eptrblock *p;    newptrb.epb_saved_eptr = eptr;
628    if ((flags & match_tail_recursed) != 0)    newptrb.epb_prev = eptrb;
629      {    eptrb = &newptrb;
     if (md->eptrn >= EPTR_WORK_SIZE) RRETURN(PCRE_ERROR_NULLWSLIMIT);  
     p = md->eptrchain + md->eptrn++;  
     }  
   else p = &newptrb;  
   p->epb_saved_eptr = eptr;  
   p->epb_prev = eptrb;  
   eptrb = p;  
630    }    }
631    
632  /* Now start processing the opcodes. */  /* Now start processing the opcodes. */
# Line 610  for (;;) Line 641  for (;;)
641    
642    if (md->partial &&    if (md->partial &&
643        eptr >= md->end_subject &&        eptr >= md->end_subject &&
644        eptr > md->start_match)        eptr > mstart)
645      md->hitend = TRUE;      md->hitend = TRUE;
646    
647    switch(op)    switch(op)
648      {      {
649        case OP_FAIL:
650        RRETURN(MATCH_NOMATCH);
651    
652        case OP_PRUNE:
653        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
654          ims, eptrb, flags, RM51);
655        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
656        RRETURN(MATCH_PRUNE);
657    
658        case OP_COMMIT:
659        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
660          ims, eptrb, flags, RM52);
661        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
662        RRETURN(MATCH_COMMIT);
663    
664        case OP_SKIP:
665        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
666          ims, eptrb, flags, RM53);
667        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
668        md->start_match_ptr = eptr;   /* Pass back current position */
669        RRETURN(MATCH_SKIP);
670    
671        case OP_THEN:
672        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
673          ims, eptrb, flags, RM54);
674        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
675        RRETURN(MATCH_THEN);
676    
677      /* Handle a capturing bracket. If there is space in the offset vector, save      /* Handle a capturing bracket. If there is space in the offset vector, save
678      the current subject position in the working slot at the top of the vector.      the current subject position in the working slot at the top of the vector.
679      We mustn't change the current values of the data slot, because they may be      We mustn't change the current values of the data slot, because they may be
# Line 656  for (;;) Line 715  for (;;)
715          {          {
716          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
717            ims, eptrb, flags, RM1);            ims, eptrb, flags, RM1);
718          if (rrc != MATCH_NOMATCH) RRETURN(rrc);          if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
719          md->capture_last = save_capture_last;          md->capture_last = save_capture_last;
720          ecode += GET(ecode, 1);          ecode += GET(ecode, 1);
721          }          }
# Line 671  for (;;) Line 730  for (;;)
730        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
731        }        }
732    
733      /* Insufficient room for saving captured contents. Treat as a non-capturing      /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
734      bracket. */      as a non-capturing bracket. */
735    
736        /* VVVVVVVVVVVVVVVVVVVVVVVVV */
737        /* VVVVVVVVVVVVVVVVVVVVVVVVV */
738    
739      DPRINTF(("insufficient capture room: treat as non-capturing\n"));      DPRINTF(("insufficient capture room: treat as non-capturing\n"));
740    
741        /* VVVVVVVVVVVVVVVVVVVVVVVVV */
742        /* VVVVVVVVVVVVVVVVVVVVVVVVV */
743    
744      /* Non-capturing bracket. Loop for all the alternatives. When we get to the      /* Non-capturing bracket. Loop for all the alternatives. When we get to the
745      final alternative within the brackets, we would return the result of a      final alternative within the brackets, we would return the result of a
746      recursive call to match() whatever happened. We can reduce stack usage by      recursive call to match() whatever happened. We can reduce stack usage by
747      turning this into a tail recursion. */      turning this into a tail recursion, except in the case when match_cbegroup
748        is set.*/
749    
750      case OP_BRA:      case OP_BRA:
751      case OP_SBRA:      case OP_SBRA:
# Line 687  for (;;) Line 753  for (;;)
753      flags = (op >= OP_SBRA)? match_cbegroup : 0;      flags = (op >= OP_SBRA)? match_cbegroup : 0;
754      for (;;)      for (;;)
755        {        {
756        if (ecode[GET(ecode, 1)] != OP_ALT)        if (ecode[GET(ecode, 1)] != OP_ALT)   /* Final alternative */
757          {          {
758          ecode += _pcre_OP_lengths[*ecode];          if (flags == 0)    /* Not a possibly empty group */
759          flags |= match_tail_recursed;            {
760          DPRINTF(("bracket 0 tail recursion\n"));            ecode += _pcre_OP_lengths[*ecode];
761          goto TAIL_RECURSE;            DPRINTF(("bracket 0 tail recursion\n"));
762              goto TAIL_RECURSE;
763              }
764    
765            /* Possibly empty group; can't use tail recursion. */
766    
767            RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
768              eptrb, flags, RM48);
769            RRETURN(rrc);
770          }          }
771    
772        /* For non-final alternatives, continue the loop for a NOMATCH result;        /* For non-final alternatives, continue the loop for a NOMATCH result;
# Line 700  for (;;) Line 774  for (;;)
774    
775        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
776          eptrb, flags, RM2);          eptrb, flags, RM2);
777        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
778        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
779        }        }
780      /* Control never reaches here. */      /* Control never reaches here. */
# Line 713  for (;;) Line 787  for (;;)
787    
788      case OP_COND:      case OP_COND:
789      case OP_SCOND:      case OP_SCOND:
790        /* Because of the way auto-callout works during compile, a callout item is
791        inserted between OP_COND and an assertion condition. */
792    
793        if (ecode[LINK_SIZE+1] == OP_CALLOUT)
794          {
795          if (pcre_callout != NULL)
796            {
797            pcre_callout_block cb;
798            cb.version          = 1;   /* Version 1 of the callout block */
799            cb.callout_number   = ecode[LINK_SIZE+2];
800            cb.offset_vector    = md->offset_vector;
801            cb.subject          = (PCRE_SPTR)md->start_subject;
802            cb.subject_length   = md->end_subject - md->start_subject;
803            cb.start_match      = mstart - md->start_subject;
804            cb.current_position = eptr - md->start_subject;
805            cb.pattern_position = GET(ecode, LINK_SIZE + 3);
806            cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
807            cb.capture_top      = offset_top/2;
808            cb.capture_last     = md->capture_last;
809            cb.callout_data     = md->callout_data;
810            if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
811            if (rrc < 0) RRETURN(rrc);
812            }
813          ecode += _pcre_OP_lengths[OP_CALLOUT];
814          }
815    
816        /* Now see what the actual condition is */
817    
818      if (ecode[LINK_SIZE+1] == OP_RREF)         /* Recursion test */      if (ecode[LINK_SIZE+1] == OP_RREF)         /* Recursion test */
819        {        {
820        offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/        offset = GET2(ecode, LINK_SIZE + 2);     /* Recursion group number*/
# Line 748  for (;;) Line 850  for (;;)
850          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
851          while (*ecode == OP_ALT) ecode += GET(ecode, 1);          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
852          }          }
853        else if (rrc != MATCH_NOMATCH)        else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
854          {          {
855          RRETURN(rrc);         /* Need braces because of following else */          RRETURN(rrc);         /* Need braces because of following else */
856          }          }
# Line 760  for (;;) Line 862  for (;;)
862        }        }
863    
864      /* 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,
865      we can use tail recursion to avoid using another stack frame. If the second      we can use tail recursion to avoid using another stack frame, except when
866      alternative doesn't exist, we can just plough on. */      match_cbegroup is required for an unlimited repeat of a possibly empty
867        group. If the second alternative doesn't exist, we can just plough on. */
868    
869      if (condition || *ecode == OP_ALT)      if (condition || *ecode == OP_ALT)
870        {        {
871        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
872        flags = match_tail_recursed | ((op == OP_SCOND)? match_cbegroup : 0);        if (op == OP_SCOND)        /* Possibly empty group */
873        goto TAIL_RECURSE;          {
874            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, match_cbegroup, RM49);
875            RRETURN(rrc);
876            }
877          else                       /* Group must match something */
878            {
879            flags = 0;
880            goto TAIL_RECURSE;
881            }
882        }        }
883      else      else                         /* Condition false & no 2nd alternative */
884        {        {
885        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
886        }        }
887      break;      break;
888    
889    
890      /* End of the pattern. If we are in a top-level recursion, we should      /* End of the pattern, either real or forced. If we are in a top-level
891      restore the offsets appropriately and continue from after the call. */      recursion, we should restore the offsets appropriately and continue from
892        after the call. */
893    
894        case OP_ACCEPT:
895      case OP_END:      case OP_END:
896      if (md->recursive != NULL && md->recursive->group_num == 0)      if (md->recursive != NULL && md->recursive->group_num == 0)
897        {        {
# Line 787  for (;;) Line 900  for (;;)
900        md->recursive = rec->prevrec;        md->recursive = rec->prevrec;
901        memmove(md->offset_vector, rec->offset_save,        memmove(md->offset_vector, rec->offset_save,
902          rec->saved_max * sizeof(int));          rec->saved_max * sizeof(int));
903        md->start_match = rec->save_start;        mstart = rec->save_start;
904        ims = original_ims;        ims = original_ims;
905        ecode = rec->after_call;        ecode = rec->after_call;
906        break;        break;
# Line 796  for (;;) Line 909  for (;;)
909      /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty      /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
910      string - backtracking will then try other alternatives, if any. */      string - backtracking will then try other alternatives, if any. */
911    
912      if (md->notempty && eptr == md->start_match) RRETURN(MATCH_NOMATCH);      if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);
913      md->end_match_ptr = eptr;          /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
914      md->end_offset_top = offset_top;   /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
915        md->start_match_ptr = mstart;       /* and the start (\K can modify) */
916      RRETURN(MATCH_MATCH);      RRETURN(MATCH_MATCH);
917    
918      /* Change option settings */      /* Change option settings */
# Line 822  for (;;) Line 936  for (;;)
936        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
937          RM4);          RM4);
938        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH) break;
939        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
940        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
941        }        }
942      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 849  for (;;) Line 963  for (;;)
963        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
964          RM5);          RM5);
965        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
966        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
967        ecode += GET(ecode,1);        ecode += GET(ecode,1);
968        }        }
969      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 873  for (;;) Line 987  for (;;)
987          {          {
988          eptr--;          eptr--;
989          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
990          BACKCHAR(eptr)          BACKCHAR(eptr);
991          }          }
992        }        }
993      else      else
# Line 904  for (;;) Line 1018  for (;;)
1018        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
1019        cb.subject          = (PCRE_SPTR)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
1020        cb.subject_length   = md->end_subject - md->start_subject;        cb.subject_length   = md->end_subject - md->start_subject;
1021        cb.start_match      = md->start_match - md->start_subject;        cb.start_match      = mstart - md->start_subject;
1022        cb.current_position = eptr - md->start_subject;        cb.current_position = eptr - md->start_subject;
1023        cb.pattern_position = GET(ecode, 2);        cb.pattern_position = GET(ecode, 2);
1024        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
# Line 966  for (;;) Line 1080  for (;;)
1080    
1081        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1082              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
1083        new_recursive.save_start = md->start_match;        new_recursive.save_start = mstart;
1084        md->start_match = eptr;        mstart = eptr;
1085    
1086        /* OK, now we can do the recursion. For each top-level alternative we        /* OK, now we can do the recursion. For each top-level alternative we
1087        restore the offset and recursion data. */        restore the offset and recursion data. */
# Line 986  for (;;) Line 1100  for (;;)
1100              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1101            RRETURN(MATCH_MATCH);            RRETURN(MATCH_MATCH);
1102            }            }
1103          else if (rrc != MATCH_NOMATCH)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1104            {            {
1105            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1106            RRETURN(rrc);            RRETURN(rrc);
# Line 1020  for (;;) Line 1134  for (;;)
1134    
1135      do      do
1136        {        {
1137        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
         eptrb, 0, RM7);  
1138        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH) break;
1139        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1140        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1141        }        }
1142      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 1066  for (;;) Line 1179  for (;;)
1179    
1180      if (*ecode == OP_KETRMIN)      if (*ecode == OP_KETRMIN)
1181        {        {
1182        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM8);
         RM8);  
1183        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1184        ecode = prev;        ecode = prev;
1185        flags = match_tail_recursed;        flags = 0;
1186        goto TAIL_RECURSE;        goto TAIL_RECURSE;
1187        }        }
1188      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
# Line 1078  for (;;) Line 1190  for (;;)
1190        RMATCH(eptr, prev, offset_top, md, ims, eptrb, match_cbegroup, RM9);        RMATCH(eptr, prev, offset_top, md, ims, eptrb, match_cbegroup, RM9);
1191        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1192        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
1193        flags = match_tail_recursed;        flags = 0;
1194        goto TAIL_RECURSE;        goto TAIL_RECURSE;
1195        }        }
1196      /* Control never gets here */      /* Control never gets here */
# Line 1090  for (;;) Line 1202  for (;;)
1202      do ecode += GET(ecode,1); while (*ecode == OP_ALT);      do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1203      break;      break;
1204    
1205      /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating      /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
1206      that it may occur zero times. It may repeat infinitely, or not at all -      indicating that it may occur zero times. It may repeat infinitely, or not
1207      i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper      at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
1208      repeat limits are compiled as a number of copies, with the optional ones      with fixed upper repeat limits are compiled as a number of copies, with the
1209      preceded by BRAZERO or BRAMINZERO. */      optional ones preceded by BRAZERO or BRAMINZERO. */
1210    
1211      case OP_BRAZERO:      case OP_BRAZERO:
1212        {        {
# Line 1116  for (;;) Line 1228  for (;;)
1228        }        }
1229      break;      break;
1230    
1231        case OP_SKIPZERO:
1232          {
1233          next = ecode+1;
1234          do next += GET(next,1); while (*next == OP_ALT);
1235          ecode = next + 1 + LINK_SIZE;
1236          }
1237        break;
1238    
1239      /* End of a group, repeated or non-repeating. */      /* End of a group, repeated or non-repeating. */
1240    
1241      case OP_KET:      case OP_KET:
# Line 1180  for (;;) Line 1300  for (;;)
1300          recursion_info *rec = md->recursive;          recursion_info *rec = md->recursive;
1301          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));          DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
1302          md->recursive = rec->prevrec;          md->recursive = rec->prevrec;
1303          md->start_match = rec->save_start;          mstart = rec->save_start;
1304          memcpy(md->offset_vector, rec->offset_save,          memcpy(md->offset_vector, rec->offset_save,
1305            rec->saved_max * sizeof(int));            rec->saved_max * sizeof(int));
1306          ecode = rec->after_call;          ecode = rec->after_call;
# Line 1209  for (;;) Line 1329  for (;;)
1329    
1330      /* The repeating kets try the rest of the pattern or restart from the      /* The repeating kets try the rest of the pattern or restart from the
1331      preceding bracket, in the appropriate order. In the second case, we can use      preceding bracket, in the appropriate order. In the second case, we can use
1332      tail recursion to avoid using another stack frame. */      tail recursion to avoid using another stack frame, unless we have an
1333        unlimited repeat of a group that can match an empty string. */
1334    
1335      flags = (*prev >= OP_SBRA)? match_cbegroup : 0;      flags = (*prev >= OP_SBRA)? match_cbegroup : 0;
1336    
1337      if (*ecode == OP_KETRMIN)      if (*ecode == OP_KETRMIN)
1338        {        {
1339        RMATCH(eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM12);
         RM12);  
1340        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1341          if (flags != 0)    /* Could match an empty string */
1342            {
1343            RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM50);
1344            RRETURN(rrc);
1345            }
1346        ecode = prev;        ecode = prev;
       flags |= match_tail_recursed;  
1347        goto TAIL_RECURSE;        goto TAIL_RECURSE;
1348        }        }
1349      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
# Line 1227  for (;;) Line 1351  for (;;)
1351        RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM13);        RMATCH(eptr, prev, offset_top, md, ims, eptrb, flags, RM13);
1352        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1353        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
1354        flags = match_tail_recursed;        flags = 0;
1355        goto TAIL_RECURSE;        goto TAIL_RECURSE;
1356        }        }
1357      /* Control never gets here */      /* Control never gets here */
# Line 1260  for (;;) Line 1384  for (;;)
1384      ecode++;      ecode++;
1385      break;      break;
1386    
1387        /* Reset the start of match point */
1388    
1389        case OP_SET_SOM:
1390        mstart = eptr;
1391        ecode++;
1392        break;
1393    
1394      /* Assert before internal newline if multiline, or before a terminating      /* Assert before internal newline if multiline, or before a terminating
1395      newline unless endonly is set, else end of subject unless noteol is set. */      newline unless endonly is set, else end of subject unless noteol is set. */
1396    
# Line 1352  for (;;) Line 1483  for (;;)
1483      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1484    
1485      case OP_ANY:      case OP_ANY:
1486      if ((ims & PCRE_DOTALL) == 0)      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
1487        {      /* Fall through */
1488        if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);  
1489        }      case OP_ALLANY:
1490      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
1491      if (utf8)      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
       while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  
1492      ecode++;      ecode++;
1493      break;      break;
1494    
# Line 1457  for (;;) Line 1587  for (;;)
1587        case 0x000d:        case 0x000d:
1588        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1589        break;        break;
1590    
1591        case 0x000a:        case 0x000a:
1592          break;
1593    
1594        case 0x000b:        case 0x000b:
1595        case 0x000c:        case 0x000c:
1596        case 0x0085:        case 0x0085:
1597        case 0x2028:        case 0x2028:
1598        case 0x2029:        case 0x2029:
1599          if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
1600          break;
1601          }
1602        ecode++;
1603        break;
1604    
1605        case OP_NOT_HSPACE:
1606        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1607        GETCHARINCTEST(c, eptr);
1608        switch(c)
1609          {
1610          default: break;
1611          case 0x09:      /* HT */
1612          case 0x20:      /* SPACE */
1613          case 0xa0:      /* NBSP */
1614          case 0x1680:    /* OGHAM SPACE MARK */
1615          case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1616          case 0x2000:    /* EN QUAD */
1617          case 0x2001:    /* EM QUAD */
1618          case 0x2002:    /* EN SPACE */
1619          case 0x2003:    /* EM SPACE */
1620          case 0x2004:    /* THREE-PER-EM SPACE */
1621          case 0x2005:    /* FOUR-PER-EM SPACE */
1622          case 0x2006:    /* SIX-PER-EM SPACE */
1623          case 0x2007:    /* FIGURE SPACE */
1624          case 0x2008:    /* PUNCTUATION SPACE */
1625          case 0x2009:    /* THIN SPACE */
1626          case 0x200A:    /* HAIR SPACE */
1627          case 0x202f:    /* NARROW NO-BREAK SPACE */
1628          case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1629          case 0x3000:    /* IDEOGRAPHIC SPACE */
1630          RRETURN(MATCH_NOMATCH);
1631          }
1632        ecode++;
1633        break;
1634    
1635        case OP_HSPACE:
1636        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1637        GETCHARINCTEST(c, eptr);
1638        switch(c)
1639          {
1640          default: RRETURN(MATCH_NOMATCH);
1641          case 0x09:      /* HT */
1642          case 0x20:      /* SPACE */
1643          case 0xa0:      /* NBSP */
1644          case 0x1680:    /* OGHAM SPACE MARK */
1645          case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
1646          case 0x2000:    /* EN QUAD */
1647          case 0x2001:    /* EM QUAD */
1648          case 0x2002:    /* EN SPACE */
1649          case 0x2003:    /* EM SPACE */
1650          case 0x2004:    /* THREE-PER-EM SPACE */
1651          case 0x2005:    /* FOUR-PER-EM SPACE */
1652          case 0x2006:    /* SIX-PER-EM SPACE */
1653          case 0x2007:    /* FIGURE SPACE */
1654          case 0x2008:    /* PUNCTUATION SPACE */
1655          case 0x2009:    /* THIN SPACE */
1656          case 0x200A:    /* HAIR SPACE */
1657          case 0x202f:    /* NARROW NO-BREAK SPACE */
1658          case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
1659          case 0x3000:    /* IDEOGRAPHIC SPACE */
1660          break;
1661          }
1662        ecode++;
1663        break;
1664    
1665        case OP_NOT_VSPACE:
1666        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1667        GETCHARINCTEST(c, eptr);
1668        switch(c)
1669          {
1670          default: break;
1671          case 0x0a:      /* LF */
1672          case 0x0b:      /* VT */
1673          case 0x0c:      /* FF */
1674          case 0x0d:      /* CR */
1675          case 0x85:      /* NEL */
1676          case 0x2028:    /* LINE SEPARATOR */
1677          case 0x2029:    /* PARAGRAPH SEPARATOR */
1678          RRETURN(MATCH_NOMATCH);
1679          }
1680        ecode++;
1681        break;
1682    
1683        case OP_VSPACE:
1684        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1685        GETCHARINCTEST(c, eptr);
1686        switch(c)
1687          {
1688          default: RRETURN(MATCH_NOMATCH);
1689          case 0x0a:      /* LF */
1690          case 0x0b:      /* VT */
1691          case 0x0c:      /* FF */
1692          case 0x0d:      /* CR */
1693          case 0x85:      /* NEL */
1694          case 0x2028:    /* LINE SEPARATOR */
1695          case 0x2029:    /* PARAGRAPH SEPARATOR */
1696        break;        break;
1697        }        }
1698      ecode++;      ecode++;
# Line 1477  for (;;) Line 1707  for (;;)
1707      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1708      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1709        {        {
1710        int chartype, script;        const ucd_record *prop = GET_UCD(c);
       int category = _pcre_ucp_findprop(c, &chartype, &script);  
1711    
1712        switch(ecode[1])        switch(ecode[1])
1713          {          {
# Line 1487  for (;;) Line 1716  for (;;)
1716          break;          break;
1717    
1718          case PT_LAMP:          case PT_LAMP:
1719          if ((chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
1720               chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
1721               chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
1722            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1723           break;           break;
1724    
1725          case PT_GC:          case PT_GC:
1726          if ((ecode[2] != category) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
1727            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1728          break;          break;
1729    
1730          case PT_PC:          case PT_PC:
1731          if ((ecode[2] != chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
1732            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1733          break;          break;
1734    
1735          case PT_SC:          case PT_SC:
1736          if ((ecode[2] != script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
1737            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1738          break;          break;
1739    
# Line 1523  for (;;) Line 1752  for (;;)
1752      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1753      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1754        {        {
1755        int chartype, script;        int category = UCD_CATEGORY(c);
       int category = _pcre_ucp_findprop(c, &chartype, &script);  
1756        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) RRETURN(MATCH_NOMATCH);
1757        while (eptr < md->end_subject)        while (eptr < md->end_subject)
1758          {          {
# Line 1533  for (;;) Line 1761  for (;;)
1761            {            {
1762            GETCHARLEN(c, eptr, len);            GETCHARLEN(c, eptr, len);
1763            }            }
1764          category = _pcre_ucp_findprop(c, &chartype, &script);          category = UCD_CATEGORY(c);
1765          if (category != ucp_M) break;          if (category != ucp_M) break;
1766          eptr += len;          eptr += len;
1767          }          }
# Line 1554  for (;;) Line 1782  for (;;)
1782      case OP_REF:      case OP_REF:
1783        {        {
1784        offset = GET2(ecode, 1) << 1;               /* Doubled ref number */        offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
1785        ecode += 3;                                 /* Advance past item */        ecode += 3;
1786    
1787          /* If the reference is unset, there are two possibilities:
1788    
1789          (a) In the default, Perl-compatible state, set the length to be longer
1790          than the amount of subject left; this ensures that every attempt at a
1791          match fails. We can't just fail here, because of the possibility of
1792          quantifiers with zero minima.
1793    
1794        /* If the reference is unset, set the length to be longer than the amount        (b) If the JavaScript compatibility flag is set, set the length to zero
1795        of subject left; this ensures that every attempt at a match fails. We        so that the back reference matches an empty string.
1796        can't just fail here, because of the possibility of quantifiers with zero  
1797        minima. */        Otherwise, set the length to the length of what was matched by the
1798          referenced subpattern. */
1799        length = (offset >= offset_top || md->offset_vector[offset] < 0)?  
1800          md->end_subject - eptr + 1 :        if (offset >= offset_top || md->offset_vector[offset] < 0)
1801          md->offset_vector[offset+1] - md->offset_vector[offset];          length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1;
1802          else
1803            length = md->offset_vector[offset+1] - md->offset_vector[offset];
1804    
1805        /* Set up for repetition, or handle the non-repeated case */        /* Set up for repetition, or handle the non-repeated case */
1806    
# Line 1838  for (;;) Line 2075  for (;;)
2075    
2076    
2077      /* Match an extended character class. This opcode is encountered only      /* Match an extended character class. This opcode is encountered only
2078      in UTF-8 mode, because that's the only time it is compiled. */      when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8
2079        mode, because Unicode properties are supported in non-UTF-8 mode. */
2080    
2081  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
2082      case OP_XCLASS:      case OP_XCLASS:
# Line 1880  for (;;) Line 2118  for (;;)
2118        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
2119          {          {
2120          if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);          if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2121          GETCHARINC(c, eptr);          GETCHARINCTEST(c, eptr);
2122          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2123          }          }
2124    
# Line 1899  for (;;) Line 2137  for (;;)
2137            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20);
2138            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2139            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2140            GETCHARINC(c, eptr);            GETCHARINCTEST(c, eptr);
2141            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);
2142            }            }
2143          /* Control never gets here */          /* Control never gets here */
# Line 1914  for (;;) Line 2152  for (;;)
2152            {            {
2153            int len = 1;            int len = 1;
2154            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject) break;
2155            GETCHARLEN(c, eptr, len);            GETCHARLENTEST(c, eptr, len);
2156            if (!_pcre_xclass(c, data)) break;            if (!_pcre_xclass(c, data)) break;
2157            eptr += len;            eptr += len;
2158            }            }
# Line 1923  for (;;) Line 2161  for (;;)
2161            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
2162            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2163            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2164            BACKCHAR(eptr)            if (utf8) BACKCHAR(eptr);
2165            }            }
2166          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2167          }          }
# Line 1989  for (;;) Line 2227  for (;;)
2227          if (fc != dc)          if (fc != dc)
2228            {            {
2229  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2230            if (dc != _pcre_ucp_othercase(fc))            if (dc != UCD_OTHERCASE(fc))
2231  #endif  #endif
2232              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2233            }            }
# Line 2080  for (;;) Line 2318  for (;;)
2318  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2319          unsigned int othercase;          unsigned int othercase;
2320          if ((ims & PCRE_CASELESS) != 0 &&          if ((ims & PCRE_CASELESS) != 0 &&
2321              (othercase = _pcre_ucp_othercase(fc)) != NOTACHAR)              (othercase = UCD_OTHERCASE(fc)) != fc)
2322            oclength = _pcre_ord2utf8(othercase, occhars);            oclength = _pcre_ord2utf8(othercase, occhars);
2323          else oclength = 0;          else oclength = 0;
2324  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
# Line 2400  for (;;) Line 2638  for (;;)
2638              {              {
2639              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
2640              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2641                if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2642              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
2643              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
2644              if (fi >= max || eptr >= md->end_subject || fc == d)              if (fc == d) RRETURN(MATCH_NOMATCH);
2645                RRETURN(MATCH_NOMATCH);  
2646              }              }
2647            }            }
2648          else          else
# Line 2509  for (;;) Line 2748  for (;;)
2748              {              {
2749              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
2750              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2751                if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2752              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
2753              if (fi >= max || eptr >= md->end_subject || fc == d)              if (fc == d) RRETURN(MATCH_NOMATCH);
               RRETURN(MATCH_NOMATCH);  
2754              }              }
2755            }            }
2756          else          else
# Line 2676  for (;;) Line 2915  for (;;)
2915            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
2916              {              {
2917              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2918              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
2919              }              }
2920            break;            break;
2921    
# Line 2684  for (;;) Line 2923  for (;;)
2923            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
2924              {              {
2925              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2926              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
2927              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
2928              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
2929                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
2930                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
# Line 2697  for (;;) Line 2936  for (;;)
2936            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
2937              {              {
2938              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2939              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
2940              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
2941              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
2942                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2943              }              }
# Line 2708  for (;;) Line 2947  for (;;)
2947            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
2948              {              {
2949              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2950              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
2951              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
2952              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
2953                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2954              }              }
# Line 2719  for (;;) Line 2958  for (;;)
2958            for (i = 1; i <= min; i++)            for (i = 1; i <= min; i++)
2959              {              {
2960              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2961              GETCHARINC(c, eptr);              GETCHARINCTEST(c, eptr);
2962              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_script = UCD_SCRIPT(c);
2963              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
2964                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2965              }              }
# Line 2739  for (;;) Line 2978  for (;;)
2978          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2979            {            {
2980            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2981            prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);            prop_category = UCD_CATEGORY(c);
2982            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
2983            while (eptr < md->end_subject)            while (eptr < md->end_subject)
2984              {              {
# Line 2748  for (;;) Line 2987  for (;;)
2987                {                {
2988                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
2989                }                }
2990              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
2991              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
2992              eptr += len;              eptr += len;
2993              }              }
# Line 2766  for (;;) Line 3005  for (;;)
3005          case OP_ANY:          case OP_ANY:
3006          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3007            {            {
3008            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject || IS_NEWLINE(eptr))
                ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))  
3009              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3010            eptr++;            eptr++;
3011            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3012            }            }
3013          break;          break;
3014    
3015            case OP_ALLANY:
3016            for (i = 1; i <= min; i++)
3017              {
3018              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3019              eptr++;
3020              while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3021              }
3022            break;
3023    
3024          case OP_ANYBYTE:          case OP_ANYBYTE:
3025          eptr += min;          eptr += min;
3026          break;          break;
# Line 2789  for (;;) Line 3036  for (;;)
3036              case 0x000d:              case 0x000d:
3037              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3038              break;              break;
3039    
3040              case 0x000a:              case 0x000a:
3041                break;
3042    
3043              case 0x000b:              case 0x000b:
3044              case 0x000c:              case 0x000c:
3045              case 0x0085:              case 0x0085:
3046              case 0x2028:              case 0x2028:
3047              case 0x2029:              case 0x2029:
3048                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3049                break;
3050                }
3051              }
3052            break;
3053    
3054            case OP_NOT_HSPACE:
3055            for (i = 1; i <= min; i++)
3056              {
3057              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3058              GETCHARINC(c, eptr);
3059              switch(c)
3060                {
3061                default: break;
3062                case 0x09:      /* HT */
3063                case 0x20:      /* SPACE */
3064                case 0xa0:      /* NBSP */
3065                case 0x1680:    /* OGHAM SPACE MARK */
3066                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3067                case 0x2000:    /* EN QUAD */
3068                case 0x2001:    /* EM QUAD */
3069                case 0x2002:    /* EN SPACE */
3070                case 0x2003:    /* EM SPACE */
3071                case 0x2004:    /* THREE-PER-EM SPACE */
3072                case 0x2005:    /* FOUR-PER-EM SPACE */
3073                case 0x2006:    /* SIX-PER-EM SPACE */
3074                case 0x2007:    /* FIGURE SPACE */
3075                case 0x2008:    /* PUNCTUATION SPACE */
3076                case 0x2009:    /* THIN SPACE */
3077                case 0x200A:    /* HAIR SPACE */
3078                case 0x202f:    /* NARROW NO-BREAK SPACE */
3079                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3080                case 0x3000:    /* IDEOGRAPHIC SPACE */
3081                RRETURN(MATCH_NOMATCH);
3082                }
3083              }
3084            break;
3085    
3086            case OP_HSPACE:
3087            for (i = 1; i <= min; i++)
3088              {
3089              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3090              GETCHARINC(c, eptr);
3091              switch(c)
3092                {
3093                default: RRETURN(MATCH_NOMATCH);
3094                case 0x09:      /* HT */
3095                case 0x20:      /* SPACE */
3096                case 0xa0:      /* NBSP */
3097                case 0x1680:    /* OGHAM SPACE MARK */
3098                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3099                case 0x2000:    /* EN QUAD */
3100                case 0x2001:    /* EM QUAD */
3101                case 0x2002:    /* EN SPACE */
3102                case 0x2003:    /* EM SPACE */
3103                case 0x2004:    /* THREE-PER-EM SPACE */
3104                case 0x2005:    /* FOUR-PER-EM SPACE */
3105                case 0x2006:    /* SIX-PER-EM SPACE */
3106                case 0x2007:    /* FIGURE SPACE */
3107                case 0x2008:    /* PUNCTUATION SPACE */
3108                case 0x2009:    /* THIN SPACE */
3109                case 0x200A:    /* HAIR SPACE */
3110                case 0x202f:    /* NARROW NO-BREAK SPACE */
3111                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3112                case 0x3000:    /* IDEOGRAPHIC SPACE */
3113                break;
3114                }
3115              }
3116            break;
3117    
3118            case OP_NOT_VSPACE:
3119            for (i = 1; i <= min; i++)
3120              {
3121              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3122              GETCHARINC(c, eptr);
3123              switch(c)
3124                {
3125                default: break;
3126                case 0x0a:      /* LF */
3127                case 0x0b:      /* VT */
3128                case 0x0c:      /* FF */
3129                case 0x0d:      /* CR */
3130                case 0x85:      /* NEL */
3131                case 0x2028:    /* LINE SEPARATOR */
3132                case 0x2029:    /* PARAGRAPH SEPARATOR */
3133                RRETURN(MATCH_NOMATCH);
3134                }
3135              }
3136            break;
3137    
3138            case OP_VSPACE:
3139            for (i = 1; i <= min; i++)
3140              {
3141              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3142              GETCHARINC(c, eptr);
3143              switch(c)
3144                {
3145                default: RRETURN(MATCH_NOMATCH);
3146                case 0x0a:      /* LF */
3147                case 0x0b:      /* VT */
3148                case 0x0c:      /* FF */
3149                case 0x0d:      /* CR */
3150                case 0x85:      /* NEL */
3151                case 0x2028:    /* LINE SEPARATOR */
3152                case 0x2029:    /* PARAGRAPH SEPARATOR */
3153              break;              break;
3154              }              }
3155            }            }
# Line 2824  for (;;) Line 3179  for (;;)
3179          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3180            {            {
3181            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3182               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
3183              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3184            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3185            }            }
3186          break;          break;
3187    
# Line 2844  for (;;) Line 3199  for (;;)
3199          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3200            {            {
3201            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3202               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))
3203              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3204            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3205            }            }
3206          break;          break;
3207    
# Line 2874  for (;;) Line 3229  for (;;)
3229        switch(ctype)        switch(ctype)
3230          {          {
3231          case OP_ANY:          case OP_ANY:
3232          if ((ims & PCRE_DOTALL) == 0)          for (i = 1; i <= min; i++)
3233            {            {
3234            for (i = 1; i <= min; i++)            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
3235              {            eptr++;
             if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);  
             eptr++;  
             }  
3236            }            }
3237          else eptr += min;          break;
3238    
3239            case OP_ALLANY:
3240            eptr += min;
3241          break;          break;
3242    
3243          case OP_ANYBYTE:          case OP_ANYBYTE:
# Line 2903  for (;;) Line 3258  for (;;)
3258              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3259              break;              break;
3260              case 0x000a:              case 0x000a:
3261                break;
3262    
3263              case 0x000b:              case 0x000b:
3264              case 0x000c:              case 0x000c:
3265              case 0x0085:              case 0x0085:
3266                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3267                break;
3268                }
3269              }
3270            break;
3271    
3272            case OP_NOT_HSPACE:
3273            for (i = 1; i <= min; i++)
3274              {
3275              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3276              switch(*eptr++)
3277                {
3278                default: break;
3279                case 0x09:      /* HT */
3280                case 0x20:      /* SPACE */
3281                case 0xa0:      /* NBSP */
3282                RRETURN(MATCH_NOMATCH);
3283                }
3284              }
3285            break;
3286    
3287            case OP_HSPACE:
3288            for (i = 1; i <= min; i++)
3289              {
3290              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3291              switch(*eptr++)
3292                {
3293                default: RRETURN(MATCH_NOMATCH);
3294                case 0x09:      /* HT */
3295                case 0x20:      /* SPACE */
3296                case 0xa0:      /* NBSP */
3297                break;
3298                }
3299              }
3300            break;
3301    
3302            case OP_NOT_VSPACE:
3303            for (i = 1; i <= min; i++)
3304              {
3305              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3306              switch(*eptr++)
3307                {
3308                default: break;
3309                case 0x0a:      /* LF */
3310                case 0x0b:      /* VT */
3311                case 0x0c:      /* FF */
3312                case 0x0d:      /* CR */
3313                case 0x85:      /* NEL */
3314                RRETURN(MATCH_NOMATCH);
3315                }
3316              }
3317            break;
3318    
3319            case OP_VSPACE:
3320            for (i = 1; i <= min; i++)
3321              {
3322              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3323              switch(*eptr++)
3324                {
3325                default: RRETURN(MATCH_NOMATCH);
3326                case 0x0a:      /* LF */
3327                case 0x0b:      /* VT */
3328                case 0x0c:      /* FF */
3329                case 0x0d:      /* CR */
3330                case 0x85:      /* NEL */
3331              break;              break;
3332              }              }
3333            }            }
# Line 2981  for (;;) Line 3403  for (;;)
3403              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3404              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3405              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3406              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3407              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3408                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3409                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
# Line 2996  for (;;) Line 3418  for (;;)
3418              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3419              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3420              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3421              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3422              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3423                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3424              }              }
# Line 3009  for (;;) Line 3431  for (;;)
3431              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3432              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3433              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3434              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3435              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3436                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3437              }              }
# Line 3022  for (;;) Line 3444  for (;;)
3444              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3445              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3446              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3447              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_script = UCD_SCRIPT(c);
3448              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3449                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3450              }              }
# Line 3044  for (;;) Line 3466  for (;;)
3466            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3467            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3468            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3469            prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);            prop_category = UCD_CATEGORY(c);
3470            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
3471            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3472              {              {
# Line 3053  for (;;) Line 3475  for (;;)
3475                {                {
3476                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3477                }                }
3478              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3479              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3480              eptr += len;              eptr += len;
3481              }              }
# Line 3072  for (;;) Line 3494  for (;;)
3494            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
3495            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3496            if (fi >= max || eptr >= md->end_subject ||            if (fi >= max || eptr >= md->end_subject ||
3497                 (ctype == OP_ANY && (ims & PCRE_DOTALL) == 0 &&                 (ctype == OP_ANY && IS_NEWLINE(eptr)))
                 IS_NEWLINE(eptr)))  
3498              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3499    
3500            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3501            switch(ctype)            switch(ctype)
3502              {              {
3503              case OP_ANY:        /* This is the DOTALL case */              case OP_ANY:        /* This is the non-NL case */
3504              break;              case OP_ALLANY:
   
3505              case OP_ANYBYTE:              case OP_ANYBYTE:
3506              break;              break;
3507    
# Line 3093  for (;;) Line 3513  for (;;)
3513                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3514                break;                break;
3515                case 0x000a:                case 0x000a:
3516                  break;
3517    
3518                case 0x000b:                case 0x000b:
3519                case 0x000c:                case 0x000c:
3520                case 0x0085:                case 0x0085:
3521                case 0x2028:                case 0x2028:
3522                case 0x2029:                case 0x2029:
3523                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3524                  break;
3525                  }
3526                break;
3527    
3528                case OP_NOT_HSPACE:
3529                switch(c)
3530                  {
3531                  default: break;
3532                  case 0x09:      /* HT */
3533                  case 0x20:      /* SPACE */
3534                  case 0xa0:      /* NBSP */
3535                  case 0x1680:    /* OGHAM SPACE MARK */
3536                  case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3537                  case 0x2000:    /* EN QUAD */
3538                  case 0x2001:    /* EM QUAD */
3539                  case 0x2002:    /* EN SPACE */
3540                  case 0x2003:    /* EM SPACE */
3541                  case 0x2004:    /* THREE-PER-EM SPACE */
3542                  case 0x2005:    /* FOUR-PER-EM SPACE */
3543                  case 0x2006:    /* SIX-PER-EM SPACE */
3544                  case 0x2007:    /* FIGURE SPACE */
3545                  case 0x2008:    /* PUNCTUATION SPACE */
3546                  case 0x2009:    /* THIN SPACE */
3547                  case 0x200A:    /* HAIR SPACE */
3548                  case 0x202f:    /* NARROW NO-BREAK SPACE */
3549                  case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3550                  case 0x3000:    /* IDEOGRAPHIC SPACE */
3551                  RRETURN(MATCH_NOMATCH);
3552                  }
3553                break;
3554    
3555                case OP_HSPACE:
3556                switch(c)
3557                  {
3558                  default: RRETURN(MATCH_NOMATCH);
3559                  case 0x09:      /* HT */
3560                  case 0x20:      /* SPACE */
3561                  case 0xa0:      /* NBSP */
3562                  case 0x1680:    /* OGHAM SPACE MARK */
3563                  case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3564                  case 0x2000:    /* EN QUAD */
3565                  case 0x2001:    /* EM QUAD */
3566                  case 0x2002:    /* EN SPACE */
3567                  case 0x2003:    /* EM SPACE */
3568                  case 0x2004:    /* THREE-PER-EM SPACE */
3569                  case 0x2005:    /* FOUR-PER-EM SPACE */
3570                  case 0x2006:    /* SIX-PER-EM SPACE */
3571                  case 0x2007:    /* FIGURE SPACE */
3572                  case 0x2008:    /* PUNCTUATION SPACE */
3573                  case 0x2009:    /* THIN SPACE */
3574                  case 0x200A:    /* HAIR SPACE */
3575                  case 0x202f:    /* NARROW NO-BREAK SPACE */
3576                  case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
3577                  case 0x3000:    /* IDEOGRAPHIC SPACE */
3578                  break;
3579                  }
3580                break;
3581    
3582                case OP_NOT_VSPACE:
3583                switch(c)
3584                  {
3585                  default: break;
3586                  case 0x0a:      /* LF */
3587                  case 0x0b:      /* VT */
3588                  case 0x0c:      /* FF */
3589                  case 0x0d:      /* CR */
3590                  case 0x85:      /* NEL */
3591                  case 0x2028:    /* LINE SEPARATOR */
3592                  case 0x2029:    /* PARAGRAPH SEPARATOR */
3593                  RRETURN(MATCH_NOMATCH);
3594                  }
3595                break;
3596    
3597                case OP_VSPACE:
3598                switch(c)
3599                  {
3600                  default: RRETURN(MATCH_NOMATCH);
3601                  case 0x0a:      /* LF */
3602                  case 0x0b:      /* VT */
3603                  case 0x0c:      /* FF */
3604                  case 0x0d:      /* CR */
3605                  case 0x85:      /* NEL */
3606                  case 0x2028:    /* LINE SEPARATOR */
3607                  case 0x2029:    /* PARAGRAPH SEPARATOR */
3608                break;                break;
3609                }                }
3610              break;              break;
# Line 3146  for (;;) Line 3653  for (;;)
3653            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
3654            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3655            if (fi >= max || eptr >= md->end_subject ||            if (fi >= max || eptr >= md->end_subject ||
3656                 ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))                 (ctype == OP_ANY && IS_NEWLINE(eptr)))
3657              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3658    
3659            c = *eptr++;            c = *eptr++;
3660            switch(ctype)            switch(ctype)
3661              {              {
3662              case OP_ANY:   /* This is the DOTALL case */              case OP_ANY:     /* This is the non-NL case */
3663              break;              case OP_ALLANY:
   
3664              case OP_ANYBYTE:              case OP_ANYBYTE:
3665              break;              break;
3666    
# Line 3165  for (;;) Line 3671  for (;;)
3671                case 0x000d:                case 0x000d:
3672                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3673                break;                break;
3674    
3675                case 0x000a:                case 0x000a:
3676                  break;
3677    
3678                case 0x000b:                case 0x000b:
3679                case 0x000c:                case 0x000c:
3680                case 0x0085:                case 0x0085:
3681                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3682                  break;
3683                  }
3684                break;
3685    
3686                case OP_NOT_HSPACE:
3687                switch(c)
3688                  {
3689                  default: break;
3690                  case 0x09:      /* HT */
3691                  case 0x20:      /* SPACE */
3692                  case 0xa0:      /* NBSP */
3693                  RRETURN(MATCH_NOMATCH);
3694                  }
3695                break;
3696    
3697                case OP_HSPACE:
3698                switch(c)
3699                  {
3700                  default: RRETURN(MATCH_NOMATCH);
3701                  case 0x09:      /* HT */
3702                  case 0x20:      /* SPACE */
3703                  case 0xa0:      /* NBSP */
3704                  break;
3705                  }
3706                break;
3707    
3708                case OP_NOT_VSPACE:
3709                switch(c)
3710                  {
3711                  default: break;
3712                  case 0x0a:      /* LF */
3713                  case 0x0b:      /* VT */
3714                  case 0x0c:      /* FF */
3715                  case 0x0d:      /* CR */
3716                  case 0x85:      /* NEL */
3717                  RRETURN(MATCH_NOMATCH);
3718                  }
3719                break;
3720    
3721                case OP_VSPACE:
3722                switch(c)
3723                  {
3724                  default: RRETURN(MATCH_NOMATCH);
3725                  case 0x0a:      /* LF */
3726                  case 0x0b:      /* VT */
3727                  case 0x0c:      /* FF */
3728                  case 0x0d:      /* CR */
3729                  case 0x85:      /* NEL */
3730                break;                break;
3731                }                }
3732              break;              break;
# Line 3235  for (;;) Line 3793  for (;;)
3793              int len = 1;              int len = 1;
3794              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3795              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3796              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3797              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3798                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3799                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
# Line 3250  for (;;) Line 3808  for (;;)
3808              int len = 1;              int len = 1;
3809              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3810              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3811              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3812              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3813                break;                break;
3814              eptr+= len;              eptr+= len;
# Line 3263  for (;;) Line 3821  for (;;)
3821              int len = 1;              int len = 1;
3822              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3823              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3824              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3825              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3826                break;                break;
3827              eptr+= len;              eptr+= len;
# Line 3276  for (;;) Line 3834  for (;;)
3834              int len = 1;              int len = 1;
3835              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3836              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3837              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_script = UCD_SCRIPT(c);
3838              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3839                break;                break;
3840              eptr+= len;              eptr+= len;
# Line 3292  for (;;) Line 3850  for (;;)
3850            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);
3851            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3852            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3853            BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
3854            }            }
3855          }          }
3856    
# Line 3305  for (;;) Line 3863  for (;;)
3863            {            {
3864            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject) break;
3865            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3866            prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);            prop_category = UCD_CATEGORY(c);
3867            if (prop_category == ucp_M) break;            if (prop_category == ucp_M) break;
3868            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3869              {              {
# Line 3314  for (;;) Line 3872  for (;;)
3872                {                {
3873                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3874                }                }
3875              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3876              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3877              eptr += len;              eptr += len;
3878              }              }
# Line 3331  for (;;) Line 3889  for (;;)
3889            for (;;)                        /* Move back over one extended */            for (;;)                        /* Move back over one extended */
3890              {              {
3891              int len = 1;              int len = 1;
             BACKCHAR(eptr);  
3892              if (!utf8) c = *eptr; else              if (!utf8) c = *eptr; else
3893                {                {
3894                  BACKCHAR(eptr);
3895                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3896                }                }
3897              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3898              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3899              eptr--;              eptr--;
3900              }              }
# Line 3354  for (;;) Line 3912  for (;;)
3912          switch(ctype)          switch(ctype)
3913            {            {
3914            case OP_ANY:            case OP_ANY:
   
           /* Special code is required for UTF8, but when the maximum is  
           unlimited we don't need it, so we repeat the non-UTF8 code. This is  
           probably worth it, because .* is quite a common idiom. */  
   
3915            if (max < INT_MAX)            if (max < INT_MAX)
3916              {              {
3917              if ((ims & PCRE_DOTALL) == 0)              for (i = min; i < max; i++)
               {  
               for (i = min; i < max; i++)  
                 {  
                 if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;  
                 eptr++;  
                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  
                 }  
               }  
             else  
3918                {                {
3919                for (i = min; i < max; i++)                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
3920                  {                eptr++;
3921                  if (eptr >= md->end_subject) break;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                 eptr++;  
                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  
                 }  
3922                }                }
3923              }              }
3924    
# Line 3385  for (;;) Line 3926  for (;;)
3926    
3927            else            else
3928              {              {
3929              if ((ims & PCRE_DOTALL) == 0)              for (i = min; i < max; i++)
3930                {                {
3931                for (i = min; i < max; i++)                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
3932                  {                eptr++;
3933                  if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                 eptr++;  
                 }  
               break;  
3934                }                }
3935              else              }
3936              break;
3937    
3938              case OP_ALLANY:
3939              if (max < INT_MAX)
3940                {
3941                for (i = min; i < max; i++)
3942                {                {
3943                c = max - min;                if (eptr >= md->end_subject) break;
3944                if (c > (unsigned int)(md->end_subject - eptr))                eptr++;
3945                  c = md->end_subject - eptr;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
               eptr += c;  
3946                }                }
3947              }              }
3948              else eptr = md->end_subject;   /* Unlimited UTF-8 repeat */
3949            break;            break;
3950    
3951            /* The byte case is the same as non-UTF8 */            /* The byte case is the same as non-UTF8 */
# Line 3426  for (;;) Line 3970  for (;;)
3970                }                }
3971              else              else
3972                {                {
3973                if (c != 0x000a && c != 0x000b && c != 0x000c &&                if (c != 0x000a &&
3974                    c != 0x0085 && c != 0x2028 && c != 0x2029)                    (md->bsr_anycrlf ||
3975                       (c != 0x000b && c != 0x000c &&
3976                        c != 0x0085 && c != 0x2028 && c != 0x2029)))
3977                  break;                  break;
3978                eptr += len;                eptr += len;
3979                }                }
3980              }              }
3981            break;            break;
3982    
3983              case OP_NOT_HSPACE:
3984              case OP_HSPACE:
3985              for (i = min; i < max; i++)
3986                {
3987                BOOL gotspace;
3988                int len = 1;
3989                if (eptr >= md->end_subject) break;
3990                GETCHARLEN(c, eptr, len);
3991                switch(c)
3992                  {
3993                  default: gotspace = FALSE; break;
3994                  case 0x09:      /* HT */
3995                  case 0x20:      /* SPACE */
3996                  case 0xa0:      /* NBSP */
3997                  case 0x1680:    /* OGHAM SPACE MARK */
3998                  case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
3999                  case 0x2000:    /* EN QUAD */
4000                  case 0x2001:    /* EM QUAD */
4001                  case 0x2002:    /* EN SPACE */
4002                  case 0x2003:    /* EM SPACE */
4003                  case 0x2004:    /* THREE-PER-EM SPACE */
4004                  case 0x2005:    /* FOUR-PER-EM SPACE */
4005                  case 0x2006:    /* SIX-PER-EM SPACE */
4006                  case 0x2007:    /* FIGURE SPACE */
4007                  case 0x2008:    /* PUNCTUATION SPACE */
4008                  case 0x2009:    /* THIN SPACE */
4009                  case 0x200A:    /* HAIR SPACE */
4010                  case 0x202f:    /* NARROW NO-BREAK SPACE */
4011                  case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4012                  case 0x3000:    /* IDEOGRAPHIC SPACE */
4013                  gotspace = TRUE;
4014                  break;
4015                  }
4016                if (gotspace == (ctype == OP_NOT_HSPACE)) break;
4017                eptr += len;
4018                }
4019              break;
4020    
4021              case OP_NOT_VSPACE:
4022              case OP_VSPACE:
4023              for (i = min; i < max; i++)
4024                {
4025                BOOL gotspace;
4026                int len = 1;
4027                if (eptr >= md->end_subject) break;
4028                GETCHARLEN(c, eptr, len);
4029                switch(c)
4030                  {
4031                  default: gotspace = FALSE; break;
4032                  case 0x0a:      /* LF */
4033                  case 0x0b:      /* VT */
4034                  case 0x0c:      /* FF */
4035                  case 0x0d:      /* CR */
4036                  case 0x85:      /* NEL */
4037                  case 0x2028:    /* LINE SEPARATOR */
4038                  case 0x2029:    /* PARAGRAPH SEPARATOR */
4039                  gotspace = TRUE;
4040                  break;
4041                  }
4042                if (gotspace == (ctype == OP_NOT_VSPACE)) break;
4043                eptr += len;
4044                }
4045              break;
4046    
4047            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
4048            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4049              {              {
# Line 3516  for (;;) Line 4126  for (;;)
4126            }            }
4127          }          }
4128        else        else
4129  #endif  #endif  /* SUPPORT_UTF8 */
4130    
4131        /* Not UTF-8 mode */        /* Not UTF-8 mode */
4132          {          {
4133          switch(ctype)          switch(ctype)
4134            {            {
4135            case OP_ANY:            case OP_ANY:
4136            if ((ims & PCRE_DOTALL) == 0)            for (i = min; i < max; i++)
4137              {              {
4138              for (i = min; i < max; i++)              if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
4139                {              eptr++;
               if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;  
               eptr++;  
               }  
             break;  
4140              }              }
4141            /* For DOTALL case, fall through and treat as \C */            break;
4142    
4143              case OP_ALLANY:
4144            case OP_ANYBYTE:            case OP_ANYBYTE:
4145            c = max - min;            c = max - min;
4146            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
# Line 3553  for (;;) Line 4160  for (;;)
4160                }                }
4161              else              else
4162                {                {
4163                if (c != 0x000a && c != 0x000b && c != 0x000c && c != 0x0085)                if (c != 0x000a &&
4164                      (md->bsr_anycrlf ||
4165                        (c != 0x000b && c != 0x000c && c != 0x0085)))
4166                  break;                  break;
4167                eptr++;                eptr++;
4168                }                }
4169              }              }
4170            break;            break;
4171    
4172              case OP_NOT_HSPACE:
4173              for (i = min; i < max; i++)
4174                {
4175                if (eptr >= md->end_subject) break;
4176                c = *eptr;
4177                if (c == 0x09 || c == 0x20 || c == 0xa0) break;
4178                eptr++;
4179                }
4180              break;
4181    
4182              case OP_HSPACE:
4183              for (i = min; i < max; i++)
4184                {
4185                if (eptr >= md->end_subject) break;
4186                c = *eptr;
4187                if (c != 0x09 && c != 0x20 && c != 0xa0) break;
4188                eptr++;
4189                }
4190              break;
4191    
4192              case OP_NOT_VSPACE:
4193              for (i = min; i < max; i++)
4194                {
4195                if (eptr >= md->end_subject) break;
4196                c = *eptr;
4197                if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85)
4198                  break;
4199                eptr++;
4200                }
4201              break;
4202    
4203              case OP_VSPACE:
4204              for (i = min; i < max; i++)
4205                {
4206                if (eptr >= md->end_subject) break;
4207                c = *eptr;
4208                if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85)
4209                  break;
4210                eptr++;
4211                }
4212              break;
4213    
4214            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
4215            for (i = min; i < max; i++)            for (i = min; i < max; i++)
4216              {              {
# Line 3661  HEAP_RETURN: Line 4312  HEAP_RETURN:
4312  switch (frame->Xwhere)  switch (frame->Xwhere)
4313    {    {
4314    LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)    LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
4315    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16)    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
4316    LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24)    LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
4317    LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32)    LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
4318    LBL(33) LBL(34) LBL(35) LBL(36) LBL(37) LBL(38) LBL(39) LBL(40)    LBL(53) LBL(54)
4319    LBL(41) LBL(42) LBL(43) LBL(44) LBL(45) LBL(46) LBL(47)  #ifdef SUPPORT_UTF8
4320      LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
4321      LBL(32) LBL(34) LBL(42) LBL(46)
4322    #ifdef SUPPORT_UCP
4323      LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
4324    #endif  /* SUPPORT_UCP */
4325    #endif  /* SUPPORT_UTF8 */
4326    default:    default:
4327    DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));    DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
4328    return PCRE_ERROR_INTERNAL;    return PCRE_ERROR_INTERNAL;
# Line 3684  Undefine all the macros that were define Line 4341  Undefine all the macros that were define
4341  #ifdef NO_RECURSE  #ifdef NO_RECURSE
4342  #undef eptr  #undef eptr
4343  #undef ecode  #undef ecode
4344    #undef mstart
4345  #undef offset_top  #undef offset_top
4346  #undef ims  #undef ims
4347  #undef eptrb  #undef eptrb
# Line 3756  Returns:          > 0 => success; value Line 4414  Returns:          > 0 => success; value
4414                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
4415  */  */
4416    
4417  PCRE_EXP_DEFN int  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
4418  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
4419    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
4420    int offsetcount)    int offsetcount)
# Line 3781  const uschar *start_bits = NULL; Line 4439  const uschar *start_bits = NULL;
4439  USPTR start_match = (USPTR)subject + start_offset;  USPTR start_match = (USPTR)subject + start_offset;
4440  USPTR end_subject;  USPTR end_subject;
4441  USPTR req_byte_ptr = start_match - 1;  USPTR req_byte_ptr = start_match - 1;
 eptrblock eptrchain[EPTR_WORK_SIZE];  
4442    
4443  pcre_study_data internal_study;  pcre_study_data internal_study;
4444  const pcre_study_data *study;  const pcre_study_data *study;
# Line 3844  if (re->magic_number != MAGIC_NUMBER) Line 4501  if (re->magic_number != MAGIC_NUMBER)
4501  /* Set up other data */  /* Set up other data */
4502    
4503  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
4504  startline = (re->options & PCRE_STARTLINE) != 0;  startline = (re->flags & PCRE_STARTLINE) != 0;
4505  firstline = (re->options & PCRE_FIRSTLINE) != 0;  firstline = (re->options & PCRE_FIRSTLINE) != 0;
4506    
4507  /* The code starts after the real_pcre block and the capture name table. */  /* The code starts after the real_pcre block and the capture name table. */
# Line 3859  end_subject = md->end_subject; Line 4516  end_subject = md->end_subject;
4516    
4517  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
4518  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
4519    md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
4520    
4521  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
4522  md->noteol = (options & PCRE_NOTEOL) != 0;  md->noteol = (options & PCRE_NOTEOL) != 0;
# Line 3867  md->partial = (options & PCRE_PARTIAL) ! Line 4525  md->partial = (options & PCRE_PARTIAL) !
4525  md->hitend = FALSE;  md->hitend = FALSE;
4526    
4527  md->recursive = NULL;                   /* No recursion at top level */  md->recursive = NULL;                   /* No recursion at top level */
 md->eptrchain = eptrchain;              /* Make workspace generally available */  
4528    
4529  md->lcc = tables + lcc_offset;  md->lcc = tables + lcc_offset;
4530  md->ctypes = tables + ctypes_offset;  md->ctypes = tables + ctypes_offset;
4531    
4532    /* Handle different \R options. */
4533    
4534    switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
4535      {
4536      case 0:
4537      if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
4538        md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
4539      else
4540    #ifdef BSR_ANYCRLF
4541      md->bsr_anycrlf = TRUE;
4542    #else
4543      md->bsr_anycrlf = FALSE;
4544    #endif
4545      break;
4546    
4547      case PCRE_BSR_ANYCRLF:
4548      md->bsr_anycrlf = TRUE;
4549      break;
4550    
4551      case PCRE_BSR_UNICODE:
4552      md->bsr_anycrlf = FALSE;
4553      break;
4554    
4555      default: return PCRE_ERROR_BADNEWLINE;
4556      }
4557    
4558  /* Handle different types of newline. The three bits give eight cases. If  /* Handle different types of newline. The three bits give eight cases. If
4559  nothing is set at run time, whatever was used at compile time applies. */  nothing is set at run time, whatever was used at compile time applies. */
4560    
4561  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
4562         PCRE_NEWLINE_BITS)          (pcre_uint32)options) & PCRE_NEWLINE_BITS)
4563    {    {
4564    case 0: newline = NEWLINE; break;   /* Compile-time default */    case 0: newline = NEWLINE; break;   /* Compile-time default */
4565    case PCRE_NEWLINE_CR: newline = '\r'; break;    case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
4566    case PCRE_NEWLINE_LF: newline = '\n'; break;    case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
4567    case PCRE_NEWLINE_CR+    case PCRE_NEWLINE_CR+
4568         PCRE_NEWLINE_LF: newline = ('\r' << 8) | '\n'; break;         PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
4569    case PCRE_NEWLINE_ANY: newline = -1; break;    case PCRE_NEWLINE_ANY: newline = -1; break;
4570    case PCRE_NEWLINE_ANYCRLF: newline = -2; break;    case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
4571    default: return PCRE_ERROR_BADNEWLINE;    default: return PCRE_ERROR_BADNEWLINE;
# Line 3915  else Line 4598  else
4598  /* Partial matching is supported only for a restricted set of regexes at the  /* Partial matching is supported only for a restricted set of regexes at the
4599  moment. */  moment. */
4600    
4601  if (md->partial && (re->options & PCRE_NOPARTIAL) != 0)  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
4602    return PCRE_ERROR_BADPARTIAL;    return PCRE_ERROR_BADPARTIAL;
4603    
4604  /* Check a UTF-8 string if required. Unfortunately there's no way of passing  /* Check a UTF-8 string if required. Unfortunately there's no way of passing
# Line 3992  studied, there may be a bitmap of possib Line 4675  studied, there may be a bitmap of possib
4675    
4676  if (!anchored)  if (!anchored)
4677    {    {
4678    if ((re->options & PCRE_FIRSTSET) != 0)    if ((re->flags & PCRE_FIRSTSET) != 0)
4679      {      {
4680      first_byte = re->first_byte & 255;      first_byte = re->first_byte & 255;
4681      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
# Line 4007  if (!anchored) Line 4690  if (!anchored)
4690  /* For anchored or unanchored matches, there may be a "last known required  /* For anchored or unanchored matches, there may be a "last known required
4691  character" set. */  character" set. */
4692    
4693  if ((re->options & PCRE_REQCHSET) != 0)  if ((re->flags & PCRE_REQCHSET) != 0)
4694    {    {
4695    req_byte = re->req_byte & 255;    req_byte = re->req_byte & 255;
4696    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
# Line 4023  the loop runs just once. */ Line 4706  the loop runs just once. */
4706  for(;;)  for(;;)
4707    {    {
4708    USPTR save_end_subject = end_subject;    USPTR save_end_subject = end_subject;
4709      USPTR new_start_match;
4710    
4711    /* Reset the maximum number of extractions we might see. */    /* Reset the maximum number of extractions we might see. */
4712    
# Line 4033  for(;;) Line 4717  for(;;)
4717      while (iptr < iend) *iptr++ = -1;      while (iptr < iend) *iptr++ = -1;
4718      }      }
4719    
4720    /* Advance to a unique first char if possible. If firstline is TRUE, the    /* If firstline is TRUE, the start of the match is constrained to the first
4721    start of the match is constrained to the first line of a multiline string.    line of a multiline string. That is, the match must be before or at the first
4722    That is, the match must be before or at the first newline. Implement this by    newline. Implement this by temporarily adjusting end_subject so that we stop
4723    temporarily adjusting end_subject so that we stop scanning at a newline. If    scanning at a newline. If the match fails at the newline, later code breaks
4724    the match fails at the newline, later code breaks this loop. */    this loop. */
4725    
4726    if (firstline)    if (firstline)
4727      {      {
4728      USPTR t = start_match;      USPTR t = start_match;
4729    #ifdef SUPPORT_UTF8
4730        if (utf8)
4731          {
4732          while (t < md->end_subject && !IS_NEWLINE(t))
4733            {
4734            t++;
4735            while (t < end_subject && (*t & 0xc0) == 0x80) t++;
4736            }
4737          }
4738        else
4739    #endif
4740      while (t < md->end_subject && !IS_NEWLINE(t)) t++;      while (t < md->end_subject && !IS_NEWLINE(t)) t++;
4741      end_subject = t;      end_subject = t;
4742      }      }
4743    
4744    /* Now test for a unique first byte */    /* There are some optimizations that avoid running the match if a known
4745      starting point is not found, or if a known later character is not present.
4746      However, there is an option that disables these, for testing and for ensuring
4747      that all callouts do actually occur. */
4748    
4749    if (first_byte >= 0)    if ((options & PCRE_NO_START_OPTIMIZE) == 0)
4750      {      {
4751      if (first_byte_caseless)      /* Advance to a unique first byte if there is one. */
       while (start_match < end_subject &&  
              md->lcc[*start_match] != first_byte)  
         start_match++;  
     else  
       while (start_match < end_subject && *start_match != first_byte)  
         start_match++;  
     }  
4752    
4753    /* Or to just after a linebreak for a multiline match if possible */      if (first_byte >= 0)
4754          {
4755          if (first_byte_caseless)
4756            while (start_match < end_subject && md->lcc[*start_match] != first_byte)
4757              start_match++;
4758          else
4759            while (start_match < end_subject && *start_match != first_byte)
4760              start_match++;
4761          }
4762    
4763    else if (startline)      /* Or to just after a linebreak for a multiline match */
4764      {  
4765      if (start_match > md->start_subject + start_offset)      else if (startline)
4766        {        {
4767        while (start_match <= end_subject && !WAS_NEWLINE(start_match))        if (start_match > md->start_subject + start_offset)
4768          start_match++;          {
4769    #ifdef SUPPORT_UTF8
4770            if (utf8)
4771              {
4772              while (start_match < end_subject && !WAS_NEWLINE(start_match))
4773                {
4774                start_match++;
4775                while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
4776                  start_match++;
4777                }
4778              }
4779            else
4780    #endif
4781            while (start_match < end_subject && !WAS_NEWLINE(start_match))
4782              start_match++;
4783    
4784        /* If we have just passed a CR and the newline option is ANY or ANYCRLF,          /* If we have just passed a CR and the newline option is ANY or ANYCRLF,
4785        and we are now at a LF, advance the match position by one more character.          and we are now at a LF, advance the match position by one more character.
4786        */          */
4787    
4788        if (start_match[-1] == '\r' &&          if (start_match[-1] == CHAR_CR &&
4789             (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&               (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
4790             start_match < end_subject &&               start_match < end_subject &&
4791             *start_match == '\n')               *start_match == CHAR_NL)
4792          start_match++;            start_match++;
4793            }
4794        }        }
     }  
4795    
4796    /* Or to a non-unique first char after study */      /* Or to a non-unique first byte after study */
4797    
4798    else if (start_bits != NULL)      else if (start_bits != NULL)
     {  
     while (start_match < end_subject)  
4799        {        {
4800        register unsigned int c = *start_match;        while (start_match < end_subject)
4801        if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break;          {
4802            register unsigned int c = *start_match;
4803            if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++;
4804              else break;
4805            }
4806        }        }
4807      }      }   /* Starting optimizations */
4808    
4809    /* Restore fudged end_subject */    /* Restore fudged end_subject */
4810    
# Line 4101  for(;;) Line 4816  for(;;)
4816    printf("\n");    printf("\n");
4817  #endif  #endif
4818    
4819    /* If req_byte is set, we know that that character must appear in the subject    /* If req_byte is set, we know that that character must appear in the
4820    for the match to succeed. If the first character is set, req_byte must be    subject for the match to succeed. If the first character is set, req_byte
4821    later in the subject; otherwise the test starts at the match point. This    must be later in the subject; otherwise the test starts at the match point.
4822    optimization can save a huge amount of backtracking in patterns with nested    This optimization can save a huge amount of backtracking in patterns with
4823    unlimited repeats that aren't going to match. Writing separate code for    nested unlimited repeats that aren't going to match. Writing separate code
4824    cased/caseless versions makes it go faster, as does using an autoincrement    for cased/caseless versions makes it go faster, as does using an
4825    and backing off on a match.    autoincrement and backing off on a match.
4826    
4827    HOWEVER: when the subject string is very, very long, searching to its end can    HOWEVER: when the subject string is very, very long, searching to its end
4828    take a long time, and give bad performance on quite ordinary patterns. This    can take a long time, and give bad performance on quite ordinary patterns.
4829    showed up when somebody was matching something like /^\d+C/ on a 32-megabyte    This showed up when somebody was matching something like /^\d+C/ on a
4830    string... so we don't do this when the string is sufficiently long.    32-megabyte string... so we don't do this when the string is sufficiently
4831      long.
4832    
4833    ALSO: this processing is disabled when partial matching is requested.    ALSO: this processing is disabled when partial matching is requested, or if
4834    */    disabling is explicitly requested. */
4835    
4836    if (req_byte >= 0 &&    if ((options & PCRE_NO_START_OPTIMIZE) == 0 &&
4837          req_byte >= 0 &&
4838        end_subject - start_match < REQ_BYTE_MAX &&        end_subject - start_match < REQ_BYTE_MAX &&
4839        !md->partial)        !md->partial)
4840      {      {
# Line 4163  for(;;) Line 4880  for(;;)
4880    
4881    /* OK, we can now run the match. */    /* OK, we can now run the match. */
4882    
4883    md->start_match = start_match;    md->start_match_ptr = start_match;
4884    md->match_call_count = 0;    md->match_call_count = 0;
4885    md->eptrn = 0;                          /* Next free eptrchain slot */    rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);
4886    rc = match(start_match, md->start_code, 2, md, ims, NULL, 0, 0);  
4887      switch(rc)
4888        {
4889        /* NOMATCH and PRUNE advance by one character. THEN at this level acts
4890        exactly like PRUNE. */
4891    
4892        case MATCH_NOMATCH:
4893        case MATCH_PRUNE:
4894        case MATCH_THEN:
4895        new_start_match = start_match + 1;
4896    #ifdef SUPPORT_UTF8
4897        if (utf8)
4898          while(new_start_match < end_subject && (*new_start_match & 0xc0) == 0x80)
4899            new_start_match++;
4900    #endif
4901        break;
4902    
4903        /* SKIP passes back the next starting point explicitly. */
4904    
4905        case MATCH_SKIP:
4906        new_start_match = md->start_match_ptr;
4907        break;
4908    
4909        /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
4910    
4911        case MATCH_COMMIT:
4912        rc = MATCH_NOMATCH;
4913        goto ENDLOOP;
4914    
4915    /* Any return other than MATCH_NOMATCH breaks the loop. */      /* Any other return is some kind of error. */
4916    
4917    if (rc != MATCH_NOMATCH) break;      default:
4918        goto ENDLOOP;
4919        }
4920    
4921      /* Control reaches here for the various types of "no match at this point"
4922      result. Reset the code to MATCH_NOMATCH for subsequent checking. */
4923    
4924      rc = MATCH_NOMATCH;
4925    
4926    /* If PCRE_FIRSTLINE is set, the match must happen before or at the first    /* If PCRE_FIRSTLINE is set, the match must happen before or at the first
4927    newline in the subject (though it may continue over the newline). Therefore,    newline in the subject (though it may continue over the newline). Therefore,
# Line 4178  for(;;) Line 4929  for(;;)
4929    
4930    if (firstline && IS_NEWLINE(start_match)) break;    if (firstline && IS_NEWLINE(start_match)) break;
4931    
4932    /* Advance the match position by one character. */    /* Advance to new matching position */
4933    
4934    start_match++;    start_match = new_start_match;
 #ifdef SUPPORT_UTF8  
   if (utf8)  
     while(start_match < end_subject && (*start_match & 0xc0) == 0x80)  
       start_match++;  
 #endif  
4935    
4936    /* Break the loop if the pattern is anchored or if we have passed the end of    /* Break the loop if the pattern is anchored or if we have passed the end of
4937    the subject. */    the subject. */
4938    
4939    if (anchored || start_match > end_subject) break;    if (anchored || start_match > end_subject) break;
4940    
4941    /* If we have just passed a CR and the newline option is CRLF or ANY or    /* If we have just passed a CR and we are now at a LF, and the pattern does
4942    ANYCRLF, and we are now at a LF, advance the match position by one more    not contain any explicit matches for \r or \n, and the newline option is CRLF
4943    character. */    or ANY or ANYCRLF, advance the match position by one more character. */
4944    
4945    if (start_match[-1] == '\r' &&    if (start_match[-1] == CHAR_CR &&
4946         (md->nltype == NLTYPE_ANY ||        start_match < end_subject &&
4947          md->nltype == NLTYPE_ANYCRLF ||        *start_match == CHAR_NL &&
4948          md->nllen == 2) &&        (re->flags & PCRE_HASCRORLF) == 0 &&
4949         start_match < end_subject &&          (md->nltype == NLTYPE_ANY ||
4950         *start_match == '\n')           md->nltype == NLTYPE_ANYCRLF ||
4951             md->nllen == 2))
4952      start_match++;      start_match++;
4953    
4954    }   /* End of for(;;) "bumpalong" loop */    }   /* End of for(;;) "bumpalong" loop */
# Line 4211  for(;;) Line 4958  for(;;)
4958  /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping  /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
4959  conditions is true:  conditions is true:
4960    
4961  (1) The pattern is anchored;  (1) The pattern is anchored or the match was failed by (*COMMIT);
4962    
4963  (2) We are past the end of the subject;  (2) We are past the end of the subject;
4964    
# Line 4226  processing, copy those that we can. In t Line 4973  processing, copy those that we can. In t
4973  certain parts of the pattern were not used, even though there are more  certain parts of the pattern were not used, even though there are more
4974  capturing parentheses than vector slots. */  capturing parentheses than vector slots. */
4975    
4976    ENDLOOP:
4977    
4978  if (rc == MATCH_MATCH)  if (rc == MATCH_MATCH)
4979    {    {
4980    if (using_temporary_offsets)    if (using_temporary_offsets)
# Line 4246  if (rc == MATCH_MATCH) Line 4995  if (rc == MATCH_MATCH)
4995    
4996    rc = md->offset_overflow? 0 : md->end_offset_top/2;    rc = md->offset_overflow? 0 : md->end_offset_top/2;
4997    
4998    /* If there is space, set up the whole thing as substring 0. */    /* If there is space, set up the whole thing as substring 0. The value of
4999      md->start_match_ptr might be modified if \K was encountered on the success
5000      matching path. */
5001    
5002    if (offsetcount < 2) rc = 0; else    if (offsetcount < 2) rc = 0; else
5003      {      {
5004      offsets[0] = start_match - md->start_subject;      offsets[0] = md->start_match_ptr - md->start_subject;
5005      offsets[1] = md->end_match_ptr - md->start_subject;      offsets[1] = md->end_match_ptr - md->start_subject;
5006      }      }
5007    

Legend:
Removed from v.165  
changed lines
  Added in v.392

  ViewVC Help
Powered by ViewVC 1.1.5