/[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 788 by ph10, Tue Dec 6 15:38:01 2011 UTC revision 1260 by ph10, Wed Feb 27 15:41:22 2013 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-2011 University of Cambridge             Copyright (c) 1997-2013 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 37  POSSIBILITY OF SUCH DAMAGE. Line 37  POSSIBILITY OF SUCH DAMAGE.
37  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
38  */  */
39    
   
40  /* This module contains pcre_exec(), the externally visible function that does  /* This module contains pcre_exec(), the externally visible function that does
41  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
42  possible. There are also some static supporting functions. */  possible. There are also some static supporting functions. */
# Line 57  possible. There are also some static sup Line 56  possible. There are also some static sup
56  #undef min  #undef min
57  #undef max  #undef max
58    
59    /* The md->capture_last field uses the lower 16 bits for the last captured
60    substring (which can never be greater than 65535) and a bit in the top half
61    to mean "capture vector overflowed". This odd way of doing things was
62    implemented when it was realized that preserving and restoring the overflow bit
63    whenever the last capture number was saved/restored made for a neater
64    interface, and doing it this way saved on (a) another variable, which would
65    have increased the stack frame size (a big NO-NO in PCRE) and (b) another
66    separate set of save/restore instructions. The following defines are used in
67    implementing this. */
68    
69    #define CAPLMASK    0x0000ffff    /* The bits used for last_capture */
70    #define OVFLMASK    0xffff0000    /* The bits used for the overflow flag */
71    #define OVFLBIT     0x00010000    /* The bit that is set for overflow */
72    
73  /* Values for setting in md->match_function_type to indicate two special types  /* Values for setting in md->match_function_type to indicate two special types
74  of call to match(). We do it this way to save on using another stack variable,  of call to match(). We do it this way to save on using another stack variable,
75  as stack usage is to be discouraged. */  as stack usage is to be discouraged. */
# Line 93  because the offset vector is always a mu Line 106  because the offset vector is always a mu
106  static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };  static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
107  static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };  static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };
108    
   
   
109  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
110  /*************************************************  /*************************************************
111  *        Debugging function to print chars       *  *        Debugging function to print chars       *
# Line 113  Returns:     nothing Line 124  Returns:     nothing
124  */  */
125    
126  static void  static void
127  pchars(const uschar *p, int length, BOOL is_subject, match_data *md)  pchars(const pcre_uchar *p, int length, BOOL is_subject, match_data *md)
128  {  {
129  unsigned int c;  pcre_uint32 c;
130    BOOL utf = md->utf;
131  if (is_subject && length > md->end_subject - p) length = md->end_subject - p;  if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
132  while (length-- > 0)  while (length-- > 0)
133    if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c);    if (isprint(c = RAWUCHARINCTEST(p))) printf("%c", (char)c); else printf("\\x{%02x}", c);
134  }  }
135  #endif  #endif
136    
# Line 140  Arguments: Line 152  Arguments:
152    md          points to match data block    md          points to match data block
153    caseless    TRUE if caseless    caseless    TRUE if caseless
154    
155  Returns:      < 0 if not matched, otherwise the number of subject bytes matched  Returns:      >= 0 the number of subject bytes matched
156                  -1 no match
157                  -2 partial match; always given if at end subject
158  */  */
159    
160  static int  static int
161  match_ref(int offset, register USPTR eptr, int length, match_data *md,  match_ref(int offset, register PCRE_PUCHAR eptr, int length, match_data *md,
162    BOOL caseless)    BOOL caseless)
163  {  {
164  USPTR eptr_start = eptr;  PCRE_PUCHAR eptr_start = eptr;
165  register USPTR p = md->start_subject + md->offset_vector[offset];  register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];
166    #ifdef SUPPORT_UTF
167    BOOL utf = md->utf;
168    #endif
169    
170  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
171  if (eptr >= md->end_subject)  if (eptr >= md->end_subject)
# Line 163  pchars(p, length, FALSE, md); Line 180  pchars(p, length, FALSE, md);
180  printf("\n");  printf("\n");
181  #endif  #endif
182    
183  /* Always fail if reference not set (and not JavaScript compatible). */  /* Always fail if reference not set (and not JavaScript compatible - in that
184    case the length is passed as zero). */
185    
186  if (length < 0) return -1;  if (length < 0) return -1;
187    
# Line 173  ASCII characters. */ Line 191  ASCII characters. */
191    
192  if (caseless)  if (caseless)
193    {    {
194  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
195  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
196    if (md->utf8)    if (utf)
197      {      {
198      /* Match characters up to the end of the reference. NOTE: the number of      /* Match characters up to the end of the reference. NOTE: the number of
199      bytes matched may differ, because there are some characters whose upper and      data units matched may differ, because in UTF-8 there are some characters
200      lower case versions code as different numbers of bytes. For example, U+023A      whose upper and lower case versions code have different numbers of bytes.
201      (2 bytes in UTF-8) is the upper case version of U+2C65 (3 bytes in UTF-8);      For example, U+023A (2 bytes in UTF-8) is the upper case version of U+2C65
202      a sequence of 3 of the former uses 6 bytes, as does a sequence of two of      (3 bytes in UTF-8); a sequence of 3 of the former uses 6 bytes, as does a
203      the latter. It is important, therefore, to check the length along the      sequence of two of the latter. It is important, therefore, to check the
204      reference, not along the subject (earlier code did this wrong). */      length along the reference, not along the subject (earlier code did this
205        wrong). */
206    
207      USPTR endptr = p + length;      PCRE_PUCHAR endptr = p + length;
208      while (p < endptr)      while (p < endptr)
209        {        {
210        int c, d;        pcre_uint32 c, d;
211        if (eptr >= md->end_subject) return -1;        const ucd_record *ur;
212          if (eptr >= md->end_subject) return -2;   /* Partial match */
213        GETCHARINC(c, eptr);        GETCHARINC(c, eptr);
214        GETCHARINC(d, p);        GETCHARINC(d, p);
215        if (c != d && c != UCD_OTHERCASE(d)) return -1;        ur = GET_UCD(d);
216          if (c != d && c != d + ur->other_case)
217            {
218            const pcre_uint32 *pp = PRIV(ucd_caseless_sets) + ur->caseset;
219            for (;;)
220              {
221              if (c < *pp) return -1;
222              if (c == *pp++) break;
223              }
224            }
225        }        }
226      }      }
227    else    else
# Line 202  if (caseless) Line 231  if (caseless)
231    /* The same code works when not in UTF-8 mode and in UTF-8 mode when there    /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
232    is no UCP support. */    is no UCP support. */
233      {      {
     if (eptr + length > md->end_subject) return -1;  
234      while (length-- > 0)      while (length-- > 0)
235        { if (md->lcc[*p++] != md->lcc[*eptr++]) return -1; }        {
236          pcre_uint32 cc, cp;
237          if (eptr >= md->end_subject) return -2;   /* Partial match */
238          cc = RAWUCHARTEST(eptr);
239          cp = RAWUCHARTEST(p);
240          if (TABLE_GET(cp, md->lcc, cp) != TABLE_GET(cc, md->lcc, cc)) return -1;
241          p++;
242          eptr++;
243          }
244      }      }
245    }    }
246    
# Line 213  are in UTF-8 mode. */ Line 249  are in UTF-8 mode. */
249    
250  else  else
251    {    {
252    if (eptr + length > md->end_subject) return -1;    while (length-- > 0)
253    while (length-- > 0) if (*p++ != *eptr++) return -1;      {
254        if (eptr >= md->end_subject) return -2;   /* Partial match */
255        if (RAWUCHARINCTEST(p) != RAWUCHARINCTEST(eptr)) return -1;
256        }
257    }    }
258    
259  return (int)(eptr - eptr_start);  return (int)(eptr - eptr_start);
# Line 269  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM Line 308  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
308         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
309         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
310         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
311         RM61,  RM62, RM63, RM64, RM65, RM66 };         RM61,  RM62, RM63, RM64, RM65, RM66, RM67, RM68 };
312    
313  /* 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
314  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 287  actually used in this definition. */ Line 326  actually used in this definition. */
326    }    }
327  #define RRETURN(ra) \  #define RRETURN(ra) \
328    { \    { \
329    printf("match() returned %d from line %d ", ra, __LINE__); \    printf("match() returned %d from line %d\n", ra, __LINE__); \
330    return ra; \    return ra; \
331    }    }
332  #else  #else
# Line 307  argument of match(), which never changes Line 346  argument of match(), which never changes
346    
347  #define RMATCH(ra,rb,rc,rd,re,rw)\  #define RMATCH(ra,rb,rc,rd,re,rw)\
348    {\    {\
349    heapframe *newframe = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));\    heapframe *newframe = frame->Xnextframe;\
350    if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\    if (newframe == NULL)\
351    frame->Xwhere = rw; \      {\
352        newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
353        if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
354        newframe->Xnextframe = NULL;\
355        frame->Xnextframe = newframe;\
356        }\
357      frame->Xwhere = rw;\
358    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
359    newframe->Xecode = rb;\    newframe->Xecode = rb;\
360    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
# Line 328  argument of match(), which never changes Line 373  argument of match(), which never changes
373    {\    {\
374    heapframe *oldframe = frame;\    heapframe *oldframe = frame;\
375    frame = oldframe->Xprevframe;\    frame = oldframe->Xprevframe;\
   (pcre_stack_free)(oldframe);\  
376    if (frame != NULL)\    if (frame != NULL)\
377      {\      {\
378      rrc = ra;\      rrc = ra;\
# Line 342  argument of match(), which never changes Line 386  argument of match(), which never changes
386    
387  typedef struct heapframe {  typedef struct heapframe {
388    struct heapframe *Xprevframe;    struct heapframe *Xprevframe;
389      struct heapframe *Xnextframe;
390    
391    /* Function arguments that may change */    /* Function arguments that may change */
392    
393    USPTR Xeptr;    PCRE_PUCHAR Xeptr;
394    const uschar *Xecode;    const pcre_uchar *Xecode;
395    USPTR Xmstart;    PCRE_PUCHAR Xmstart;
396    int Xoffset_top;    int Xoffset_top;
397    eptrblock *Xeptrb;    eptrblock *Xeptrb;
398    unsigned int Xrdepth;    unsigned int Xrdepth;
399    
400    /* Function local variables */    /* Function local variables */
401    
402    USPTR Xcallpat;    PCRE_PUCHAR Xcallpat;
403  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
404    USPTR Xcharptr;    PCRE_PUCHAR Xcharptr;
405  #endif  #endif
406    USPTR Xdata;    PCRE_PUCHAR Xdata;
407    USPTR Xnext;    PCRE_PUCHAR Xnext;
408    USPTR Xpp;    PCRE_PUCHAR Xpp;
409    USPTR Xprev;    PCRE_PUCHAR Xprev;
410    USPTR Xsaved_eptr;    PCRE_PUCHAR Xsaved_eptr;
411    
412    recursion_info Xnew_recursive;    recursion_info Xnew_recursive;
413    
# Line 372  typedef struct heapframe { Line 417  typedef struct heapframe {
417    
418  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
419    int Xprop_type;    int Xprop_type;
420    int Xprop_value;    unsigned int Xprop_value;
421    int Xprop_fail_result;    int Xprop_fail_result;
422    int Xoclength;    int Xoclength;
423    uschar Xocchars[8];    pcre_uchar Xocchars[6];
424  #endif  #endif
425    
426    int Xcodelink;    int Xcodelink;
# Line 385  typedef struct heapframe { Line 430  typedef struct heapframe {
430    int Xlength;    int Xlength;
431    int Xmax;    int Xmax;
432    int Xmin;    int Xmin;
433    int Xnumber;    unsigned int Xnumber;
434    int Xoffset;    int Xoffset;
435    int Xop;    unsigned int Xop;
436    int Xsave_capture_last;    pcre_int32 Xsave_capture_last;
437    int Xsave_offset1, Xsave_offset2, Xsave_offset3;    int Xsave_offset1, Xsave_offset2, Xsave_offset3;
438    int Xstacksave[REC_STACK_SAVE_MAX];    int Xstacksave[REC_STACK_SAVE_MAX];
439    
# Line 440  the subject. */ Line 485  the subject. */
485    
486    
487  /* Performance note: It might be tempting to extract commonly used fields from  /* Performance note: It might be tempting to extract commonly used fields from
488  the md structure (e.g. utf8, end_subject) into individual variables to improve  the md structure (e.g. utf, end_subject) into individual variables to improve
489  performance. Tests using gcc on a SPARC disproved this; in the first case, it  performance. Tests using gcc on a SPARC disproved this; in the first case, it
490  made performance worse.  made performance worse.
491    
# Line 463  Returns:       MATCH_MATCH if matched Line 508  Returns:       MATCH_MATCH if matched
508  */  */
509    
510  static int  static int
511  match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart,  match(REGISTER PCRE_PUCHAR eptr, REGISTER const pcre_uchar *ecode,
512    int offset_top, match_data *md, eptrblock *eptrb, unsigned int rdepth)    PCRE_PUCHAR mstart, int offset_top, match_data *md, eptrblock *eptrb,
513      unsigned int rdepth)
514  {  {
515  /* These variables do not need to be preserved over recursion in this function,  /* These variables do not need to be preserved over recursion in this function,
516  so they can be ordinary variables in all cases. Mark some of them with  so they can be ordinary variables in all cases. Mark some of them with
# Line 472  so they can be ordinary variables in all Line 518  so they can be ordinary variables in all
518    
519  register int  rrc;         /* Returns from recursive calls */  register int  rrc;         /* Returns from recursive calls */
520  register int  i;           /* Used for loops not involving calls to RMATCH() */  register int  i;           /* Used for loops not involving calls to RMATCH() */
521  register unsigned int c;   /* Character values not kept over RMATCH() calls */  register pcre_uint32 c;    /* Character values not kept over RMATCH() calls */
522  register BOOL utf8;        /* Local copy of UTF-8 flag for speed */  register BOOL utf;         /* Local copy of UTF flag for speed */
523    
524  BOOL minimize, possessive; /* Quantifier options */  BOOL minimize, possessive; /* Quantifier options */
525  BOOL caseless;  BOOL caseless;
526  int condcode;  int condcode;
527    
528  /* When recursion is not being used, all "local" variables that have to be  /* When recursion is not being used, all "local" variables that have to be
529  preserved over calls to RMATCH() are part of a "frame" which is obtained from  preserved over calls to RMATCH() are part of a "frame". We set up the top-level
530  heap storage. Set up the top-level frame here; others are obtained from the  frame on the stack here; subsequent instantiations are obtained from the heap
531  heap whenever RMATCH() does a "recursion". See the macro definitions above. */  whenever RMATCH() does a "recursion". See the macro definitions above. Putting
532    the top-level on the stack rather than malloc-ing them all gives a performance
533    boost in many cases where there is not much "recursion". */
534    
535  #ifdef NO_RECURSE  #ifdef NO_RECURSE
536  heapframe *frame = (heapframe *)(pcre_stack_malloc)(sizeof(heapframe));  heapframe *frame = (heapframe *)md->match_frames_base;
 if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);  
 frame->Xprevframe = NULL;            /* Marks the top level */  
537    
538  /* Copy in the original argument variables */  /* Copy in the original argument variables */
539    
# Line 513  HEAP_RECURSE: Line 559  HEAP_RECURSE:
559    
560  /* Ditto for the local variables */  /* Ditto for the local variables */
561    
562  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
563  #define charptr            frame->Xcharptr  #define charptr            frame->Xcharptr
564  #endif  #endif
565  #define callpat            frame->Xcallpat  #define callpat            frame->Xcallpat
# Line 571  declarations can be cut out in a block. Line 617  declarations can be cut out in a block.
617  below are for variables that do not have to be preserved over a recursive call  below are for variables that do not have to be preserved over a recursive call
618  to RMATCH(). */  to RMATCH(). */
619    
620  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
621  const uschar *charptr;  const pcre_uchar *charptr;
622  #endif  #endif
623  const uschar *callpat;  const pcre_uchar *callpat;
624  const uschar *data;  const pcre_uchar *data;
625  const uschar *next;  const pcre_uchar *next;
626  USPTR         pp;  PCRE_PUCHAR       pp;
627  const uschar *prev;  const pcre_uchar *prev;
628  USPTR         saved_eptr;  PCRE_PUCHAR       saved_eptr;
629    
630  recursion_info new_recursive;  recursion_info new_recursive;
631    
# Line 589  BOOL prev_is_word; Line 635  BOOL prev_is_word;
635    
636  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
637  int prop_type;  int prop_type;
638  int prop_value;  unsigned int prop_value;
639  int prop_fail_result;  int prop_fail_result;
640  int oclength;  int oclength;
641  uschar occhars[8];  pcre_uchar occhars[6];
642  #endif  #endif
643    
644  int codelink;  int codelink;
# Line 600  int ctype; Line 646  int ctype;
646  int length;  int length;
647  int max;  int max;
648  int min;  int min;
649  int number;  unsigned int number;
650  int offset;  int offset;
651  int op;  unsigned int op;
652  int save_capture_last;  pcre_int32 save_capture_last;
653  int save_offset1, save_offset2, save_offset3;  int save_offset1, save_offset2, save_offset3;
654  int stacksave[REC_STACK_SAVE_MAX];  int stacksave[REC_STACK_SAVE_MAX];
655    
656  eptrblock newptrb;  eptrblock newptrb;
657    
658    /* There is a special fudge for calling match() in a way that causes it to
659    measure the size of its basic stack frame when the stack is being used for
660    recursion. The second argument (ecode) being NULL triggers this behaviour. It
661    cannot normally ever be NULL. The return is the negated value of the frame
662    size. */
663    
664    if (ecode == NULL)
665      {
666      if (rdepth == 0)
667        return match((PCRE_PUCHAR)&rdepth, NULL, NULL, 0, NULL, NULL, 1);
668      else
669        {
670        int len = (char *)&rdepth - (char *)eptr;
671        return (len > 0)? -len : len;
672        }
673      }
674  #endif     /* NO_RECURSE */  #endif     /* NO_RECURSE */
675    
676  /* To save space on the stack and in the heap frame, I have doubled up on some  /* To save space on the stack and in the heap frame, I have doubled up on some
# Line 620  the alternative names that are used. */ Line 683  the alternative names that are used. */
683  #define code_offset   codelink  #define code_offset   codelink
684  #define condassert    condition  #define condassert    condition
685  #define matched_once  prev_is_word  #define matched_once  prev_is_word
686    #define foc           number
687    #define save_mark     data
688    
689  /* These statements are here to stop the compiler complaining about unitialized  /* These statements are here to stop the compiler complaining about unitialized
690  variables. */  variables. */
# Line 645  defined). However, RMATCH isn't like a f Line 710  defined). However, RMATCH isn't like a f
710  complicated macro. It has to be used in one particular way. This shouldn't,  complicated macro. It has to be used in one particular way. This shouldn't,
711  however, impact performance when true recursion is being used. */  however, impact performance when true recursion is being used. */
712    
713  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
714  utf8 = md->utf8;       /* Local copy of the flag */  utf = md->utf;       /* Local copy of the flag */
715  #else  #else
716  utf8 = FALSE;  utf = FALSE;
717  #endif  #endif
718    
719  /* First check that we haven't called match() too many times, or that we  /* First check that we haven't called match() too many times, or that we
# Line 689  for (;;) Line 754  for (;;)
754      case OP_MARK:      case OP_MARK:
755      md->nomatch_mark = ecode + 2;      md->nomatch_mark = ecode + 2;
756      md->mark = NULL;    /* In case previously set by assertion */      md->mark = NULL;    /* In case previously set by assertion */
757      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
758        eptrb, RM55);        eptrb, RM55);
759      if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&      if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
760           md->mark == NULL) md->mark = ecode + 2;           md->mark == NULL) md->mark = ecode + 2;
# Line 702  for (;;) Line 767  for (;;)
767      unaltered. */      unaltered. */
768    
769      else if (rrc == MATCH_SKIP_ARG &&      else if (rrc == MATCH_SKIP_ARG &&
770          strcmp((char *)(ecode + 2), (char *)(md->start_match_ptr)) == 0)          STRCMP_UC_UC_TEST(ecode + 2, md->start_match_ptr) == 0)
771        {        {
772        md->start_match_ptr = eptr;        md->start_match_ptr = eptr;
773        RRETURN(MATCH_SKIP);        RRETURN(MATCH_SKIP);
# Line 715  for (;;) Line 780  for (;;)
780      /* COMMIT overrides PRUNE, SKIP, and THEN */      /* COMMIT overrides PRUNE, SKIP, and THEN */
781    
782      case OP_COMMIT:      case OP_COMMIT:
783      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
784        eptrb, RM52);        eptrb, RM52);
785      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE &&      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE &&
786          rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&          rrc != MATCH_SKIP && rrc != MATCH_SKIP_ARG &&
# Line 726  for (;;) Line 791  for (;;)
791      /* PRUNE overrides THEN */      /* PRUNE overrides THEN */
792    
793      case OP_PRUNE:      case OP_PRUNE:
794      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
795        eptrb, RM51);        eptrb, RM51);
796      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);      if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
797      RRETURN(MATCH_PRUNE);      RRETURN(MATCH_PRUNE);
# Line 734  for (;;) Line 799  for (;;)
799      case OP_PRUNE_ARG:      case OP_PRUNE_ARG:
800      md->nomatch_mark = ecode + 2;      md->nomatch_mark = ecode + 2;
801      md->mark = NULL;    /* In case previously set by assertion */      md->mark = NULL;    /* In case previously set by assertion */
802      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
803        eptrb, RM56);        eptrb, RM56);
804      if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&      if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
805           md->mark == NULL) md->mark = ecode + 2;           md->mark == NULL) md->mark = ecode + 2;
# Line 744  for (;;) Line 809  for (;;)
809      /* SKIP overrides PRUNE and THEN */      /* SKIP overrides PRUNE and THEN */
810    
811      case OP_SKIP:      case OP_SKIP:
812      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
813        eptrb, RM53);        eptrb, RM53);
814      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
815        RRETURN(rrc);        RRETURN(rrc);
# Line 758  for (;;) Line 823  for (;;)
823      case OP_SKIP_ARG:      case OP_SKIP_ARG:
824      if (md->ignore_skip_arg)      if (md->ignore_skip_arg)
825        {        {
826        ecode += _pcre_OP_lengths[*ecode] + ecode[1];        ecode += PRIV(OP_lengths)[*ecode] + ecode[1];
827        break;        break;
828        }        }
829      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md,      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
830        eptrb, RM57);        eptrb, RM57);
831      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)      if (rrc != MATCH_NOMATCH && rrc != MATCH_PRUNE && rrc != MATCH_THEN)
832        RRETURN(rrc);        RRETURN(rrc);
# Line 779  for (;;) Line 844  for (;;)
844      match pointer to do this. */      match pointer to do this. */
845    
846      case OP_THEN:      case OP_THEN:
847      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
848        eptrb, RM54);        eptrb, RM54);
849      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
850      md->start_match_ptr = ecode;      md->start_match_ptr = ecode;
# Line 788  for (;;) Line 853  for (;;)
853      case OP_THEN_ARG:      case OP_THEN_ARG:
854      md->nomatch_mark = ecode + 2;      md->nomatch_mark = ecode + 2;
855      md->mark = NULL;    /* In case previously set by assertion */      md->mark = NULL;    /* In case previously set by assertion */
856      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top,      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top,
857        md, eptrb, RM58);        md, eptrb, RM58);
858      if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&      if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
859           md->mark == NULL) md->mark = ecode + 2;           md->mark == NULL) md->mark = ecode + 2;
# Line 812  for (;;) Line 877  for (;;)
877      case OP_ONCE_NC:      case OP_ONCE_NC:
878      prev = ecode;      prev = ecode;
879      saved_eptr = eptr;      saved_eptr = eptr;
880        save_mark = md->mark;
881      do      do
882        {        {
883        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
# Line 830  for (;;) Line 896  for (;;)
896    
897        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
898        ecode += GET(ecode,1);        ecode += GET(ecode,1);
899          md->mark = save_mark;
900        }        }
901      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
902    
# Line 869  for (;;) Line 936  for (;;)
936        }        }
937      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
938        {        {
       md->match_function_type = MATCH_CBEGROUP;  
939        RMATCH(eptr, prev, offset_top, md, eptrb, RM66);        RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
940        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
941        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
# Line 909  for (;;) Line 975  for (;;)
975        save_offset2 = md->offset_vector[offset+1];        save_offset2 = md->offset_vector[offset+1];
976        save_offset3 = md->offset_vector[md->offset_end - number];        save_offset3 = md->offset_vector[md->offset_end - number];
977        save_capture_last = md->capture_last;        save_capture_last = md->capture_last;
978          save_mark = md->mark;
979    
980        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
981        md->offset_vector[md->offset_end - number] =        md->offset_vector[md->offset_end - number] =
# Line 917  for (;;) Line 984  for (;;)
984        for (;;)        for (;;)
985          {          {
986          if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;          if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
987          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,          RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
988            eptrb, RM1);            eptrb, RM1);
989          if (rrc == MATCH_ONCE) break;  /* Backing up through an atomic group */          if (rrc == MATCH_ONCE) break;  /* Backing up through an atomic group */
990    
# Line 945  for (;;) Line 1012  for (;;)
1012          if (rrc != MATCH_NOMATCH) RRETURN(rrc);          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1013          md->capture_last = save_capture_last;          md->capture_last = save_capture_last;
1014          ecode += GET(ecode, 1);          ecode += GET(ecode, 1);
1015            md->mark = save_mark;
1016          if (*ecode != OP_ALT) break;          if (*ecode != OP_ALT) break;
1017          }          }
1018    
# Line 996  for (;;) Line 1064  for (;;)
1064    
1065      for (;;)      for (;;)
1066        {        {
1067        if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;        if (op >= OP_SBRA || op == OP_ONCE)
1068            md->match_function_type = MATCH_CBEGROUP;
1069    
1070        /* If this is not a possibly empty group, and there are no (*THEN)s in        /* If this is not a possibly empty group, and there are no (*THEN)s in
1071        the pattern, and this is the final alternative, optimize as described        the pattern, and this is the final alternative, optimize as described
# Line 1004  for (;;) Line 1073  for (;;)
1073    
1074        else if (!md->hasthen && ecode[GET(ecode, 1)] != OP_ALT)        else if (!md->hasthen && ecode[GET(ecode, 1)] != OP_ALT)
1075          {          {
1076          ecode += _pcre_OP_lengths[*ecode];          ecode += PRIV(OP_lengths)[*ecode];
1077          goto TAIL_RECURSE;          goto TAIL_RECURSE;
1078          }          }
1079    
1080        /* In all other cases, we have to make another call to match(). */        /* In all other cases, we have to make another call to match(). */
1081    
1082        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, eptrb,        save_mark = md->mark;
1083          save_capture_last = md->capture_last;
1084          RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,
1085          RM2);          RM2);
1086    
1087        /* See comment in the code for capturing groups above about handling        /* See comment in the code for capturing groups above about handling
# Line 1028  for (;;) Line 1099  for (;;)
1099          {          {
1100          if (rrc == MATCH_ONCE)          if (rrc == MATCH_ONCE)
1101            {            {
1102            const uschar *scode = ecode;            const pcre_uchar *scode = ecode;
1103            if (*scode != OP_ONCE)           /* If not at start, find it */            if (*scode != OP_ONCE)           /* If not at start, find it */
1104              {              {
1105              while (*scode == OP_ALT) scode += GET(scode, 1);              while (*scode == OP_ALT) scode += GET(scode, 1);
# Line 1039  for (;;) Line 1110  for (;;)
1110          RRETURN(rrc);          RRETURN(rrc);
1111          }          }
1112        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1113          md->mark = save_mark;
1114        if (*ecode != OP_ALT) break;        if (*ecode != OP_ALT) break;
1115          md->capture_last = save_capture_last;
1116        }        }
1117    
1118      RRETURN(MATCH_NOMATCH);      RRETURN(MATCH_NOMATCH);
# Line 1093  for (;;) Line 1166  for (;;)
1166          md->offset_vector[md->offset_end - number] =          md->offset_vector[md->offset_end - number] =
1167            (int)(eptr - md->start_subject);            (int)(eptr - md->start_subject);
1168          if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;          if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1169          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,          RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
1170            eptrb, RM63);            eptrb, RM63);
1171          if (rrc == MATCH_KETRPOS)          if (rrc == MATCH_KETRPOS)
1172            {            {
# Line 1161  for (;;) Line 1234  for (;;)
1234      POSSESSIVE_NON_CAPTURE:      POSSESSIVE_NON_CAPTURE:
1235      matched_once = FALSE;      matched_once = FALSE;
1236      code_offset = (int)(ecode - md->start_code);      code_offset = (int)(ecode - md->start_code);
1237        save_capture_last = md->capture_last;
1238    
1239      for (;;)      for (;;)
1240        {        {
1241        if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;        if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
1242        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,        RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
1243          eptrb, RM48);          eptrb, RM48);
1244        if (rrc == MATCH_KETRPOS)        if (rrc == MATCH_KETRPOS)
1245          {          {
# Line 1190  for (;;) Line 1264  for (;;)
1264        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
1265        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1266        if (*ecode != OP_ALT) break;        if (*ecode != OP_ALT) break;
1267          md->capture_last = save_capture_last;
1268        }        }
1269    
1270      if (matched_once || allow_zero)      if (matched_once || allow_zero)
# Line 1215  for (;;) Line 1290  for (;;)
1290    
1291      if (ecode[LINK_SIZE+1] == OP_CALLOUT)      if (ecode[LINK_SIZE+1] == OP_CALLOUT)
1292        {        {
1293        if (pcre_callout != NULL)        if (PUBL(callout) != NULL)
1294          {          {
1295          pcre_callout_block cb;          PUBL(callout_block) cb;
1296          cb.version          = 2;   /* Version 1 of the callout block */          cb.version          = 2;   /* Version 1 of the callout block */
1297          cb.callout_number   = ecode[LINK_SIZE+2];          cb.callout_number   = ecode[LINK_SIZE+2];
1298          cb.offset_vector    = md->offset_vector;          cb.offset_vector    = md->offset_vector;
1299    #if defined COMPILE_PCRE8
1300          cb.subject          = (PCRE_SPTR)md->start_subject;          cb.subject          = (PCRE_SPTR)md->start_subject;
1301    #elif defined COMPILE_PCRE16
1302            cb.subject          = (PCRE_SPTR16)md->start_subject;
1303    #elif defined COMPILE_PCRE32
1304            cb.subject          = (PCRE_SPTR32)md->start_subject;
1305    #endif
1306          cb.subject_length   = (int)(md->end_subject - md->start_subject);          cb.subject_length   = (int)(md->end_subject - md->start_subject);
1307          cb.start_match      = (int)(mstart - md->start_subject);          cb.start_match      = (int)(mstart - md->start_subject);
1308          cb.current_position = (int)(eptr - md->start_subject);          cb.current_position = (int)(eptr - md->start_subject);
1309          cb.pattern_position = GET(ecode, LINK_SIZE + 3);          cb.pattern_position = GET(ecode, LINK_SIZE + 3);
1310          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);          cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE);
1311          cb.capture_top      = offset_top/2;          cb.capture_top      = offset_top/2;
1312          cb.capture_last     = md->capture_last;          cb.capture_last     = md->capture_last & CAPLMASK;
1313            /* Internal change requires this for API compatibility. */
1314            if (cb.capture_last == 0) cb.capture_last = -1;
1315          cb.callout_data     = md->callout_data;          cb.callout_data     = md->callout_data;
1316          cb.mark             = md->nomatch_mark;          cb.mark             = md->nomatch_mark;
1317          if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);          if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1318          if (rrc < 0) RRETURN(rrc);          if (rrc < 0) RRETURN(rrc);
1319          }          }
1320        ecode += _pcre_OP_lengths[OP_CALLOUT];        ecode += PRIV(OP_lengths)[OP_CALLOUT];
1321        }        }
1322    
1323      condcode = ecode[LINK_SIZE+1];      condcode = ecode[LINK_SIZE+1];
# Line 1250  for (;;) Line 1333  for (;;)
1333          }          }
1334        else        else
1335          {          {
1336          int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/          unsigned int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
1337          condition = (recno == RREF_ANY || recno == md->recursive->group_num);          condition = (recno == RREF_ANY || recno == md->recursive->group_num);
1338    
1339          /* If the test is for recursion into a specific subpattern, and it is          /* If the test is for recursion into a specific subpattern, and it is
# Line 1260  for (;;) Line 1343  for (;;)
1343    
1344          if (!condition && condcode == OP_NRREF)          if (!condition && condcode == OP_NRREF)
1345            {            {
1346            uschar *slotA = md->name_table;            pcre_uchar *slotA = md->name_table;
1347            for (i = 0; i < md->name_count; i++)            for (i = 0; i < md->name_count; i++)
1348              {              {
1349              if (GET2(slotA, 0) == recno) break;              if (GET2(slotA, 0) == recno) break;
# Line 1273  for (;;) Line 1356  for (;;)
1356    
1357            if (i < md->name_count)            if (i < md->name_count)
1358              {              {
1359              uschar *slotB = slotA;              pcre_uchar *slotB = slotA;
1360              while (slotB > md->name_table)              while (slotB > md->name_table)
1361                {                {
1362                slotB -= md->name_entry_size;                slotB -= md->name_entry_size;
1363                if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)                if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
1364                  {                  {
1365                  condition = GET2(slotB, 0) == md->recursive->group_num;                  condition = GET2(slotB, 0) == md->recursive->group_num;
1366                  if (condition) break;                  if (condition) break;
# Line 1293  for (;;) Line 1376  for (;;)
1376                for (i++; i < md->name_count; i++)                for (i++; i < md->name_count; i++)
1377                  {                  {
1378                  slotB += md->name_entry_size;                  slotB += md->name_entry_size;
1379                  if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)                  if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
1380                    {                    {
1381                    condition = GET2(slotB, 0) == md->recursive->group_num;                    condition = GET2(slotB, 0) == md->recursive->group_num;
1382                    if (condition) break;                    if (condition) break;
# Line 1306  for (;;) Line 1389  for (;;)
1389    
1390          /* Chose branch according to the condition */          /* Chose branch according to the condition */
1391    
1392          ecode += condition? 3 : GET(ecode, 1);          ecode += condition? 1 + IMM2_SIZE : GET(ecode, 1);
1393          }          }
1394        }        }
1395    
# Line 1322  for (;;) Line 1405  for (;;)
1405    
1406        if (!condition && condcode == OP_NCREF)        if (!condition && condcode == OP_NCREF)
1407          {          {
1408          int refno = offset >> 1;          unsigned int refno = offset >> 1;
1409          uschar *slotA = md->name_table;          pcre_uchar *slotA = md->name_table;
1410    
1411          for (i = 0; i < md->name_count; i++)          for (i = 0; i < md->name_count; i++)
1412            {            {
# Line 1337  for (;;) Line 1420  for (;;)
1420    
1421          if (i < md->name_count)          if (i < md->name_count)
1422            {            {
1423            uschar *slotB = slotA;            pcre_uchar *slotB = slotA;
1424            while (slotB > md->name_table)            while (slotB > md->name_table)
1425              {              {
1426              slotB -= md->name_entry_size;              slotB -= md->name_entry_size;
1427              if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)              if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
1428                {                {
1429                offset = GET2(slotB, 0) << 1;                offset = GET2(slotB, 0) << 1;
1430                condition = offset < offset_top &&                condition = offset < offset_top &&
# Line 1359  for (;;) Line 1442  for (;;)
1442              for (i++; i < md->name_count; i++)              for (i++; i < md->name_count; i++)
1443                {                {
1444                slotB += md->name_entry_size;                slotB += md->name_entry_size;
1445                if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0)                if (STRCMP_UC_UC(slotA + IMM2_SIZE, slotB + IMM2_SIZE) == 0)
1446                  {                  {
1447                  offset = GET2(slotB, 0) << 1;                  offset = GET2(slotB, 0) << 1;
1448                  condition = offset < offset_top &&                  condition = offset < offset_top &&
# Line 1374  for (;;) Line 1457  for (;;)
1457    
1458        /* Chose branch according to the condition */        /* Chose branch according to the condition */
1459    
1460        ecode += condition? 3 : GET(ecode, 1);        ecode += condition? 1 + IMM2_SIZE : GET(ecode, 1);
1461        }        }
1462    
1463      else if (condcode == OP_DEF)     /* DEFINE - always false */      else if (condcode == OP_DEF)     /* DEFINE - always false */
# Line 1450  for (;;) Line 1533  for (;;)
1533      to close any currently open capturing brackets. */      to close any currently open capturing brackets. */
1534    
1535      case OP_CLOSE:      case OP_CLOSE:
1536      number = GET2(ecode, 1);      number = GET2(ecode, 1);   /* Must be less than 65536 */
1537      offset = number << 1;      offset = number << 1;
1538    
1539  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
# Line 1458  for (;;) Line 1541  for (;;)
1541        printf("\n");        printf("\n");
1542  #endif  #endif
1543    
1544      md->capture_last = number;      md->capture_last = (md->capture_last & OVFLMASK) | number;
1545      if (offset >= md->offset_max) md->offset_overflow = TRUE; else      if (offset >= md->offset_max) md->capture_last |= OVFLBIT; else
1546        {        {
1547        md->offset_vector[offset] =        md->offset_vector[offset] =
1548          md->offset_vector[md->offset_end - number];          md->offset_vector[md->offset_end - number];
1549        md->offset_vector[offset+1] = (int)(eptr - md->start_subject);        md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
1550        if (offset_top <= offset) offset_top = offset + 2;        if (offset_top <= offset) offset_top = offset + 2;
1551        }        }
1552      ecode += 3;      ecode += 1 + IMM2_SIZE;
1553      break;      break;
1554    
1555    
# Line 1513  for (;;) Line 1596  for (;;)
1596    
1597      case OP_ASSERT:      case OP_ASSERT:
1598      case OP_ASSERTBACK:      case OP_ASSERTBACK:
1599        save_mark = md->mark;
1600      if (md->match_function_type == MATCH_CONDASSERT)      if (md->match_function_type == MATCH_CONDASSERT)
1601        {        {
1602        condassert = TRUE;        condassert = TRUE;
# Line 1528  for (;;) Line 1612  for (;;)
1612          mstart = md->start_match_ptr;   /* In case \K reset it */          mstart = md->start_match_ptr;   /* In case \K reset it */
1613          break;          break;
1614          }          }
1615          md->mark = save_mark;
1616    
1617        /* PCRE does not allow THEN to escape beyond an assertion; it is treated        /* A COMMIT failure must fail the entire assertion, without trying any
1618        as NOMATCH. */        subsequent branches. */
1619    
1620          if (rrc == MATCH_COMMIT) RRETURN(MATCH_NOMATCH);
1621    
1622          /* PCRE does not allow THEN to escape beyond an assertion; it
1623          is treated as NOMATCH. */
1624    
1625        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1626        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
# Line 1557  for (;;) Line 1647  for (;;)
1647    
1648      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1649      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
1650        save_mark = md->mark;
1651      if (md->match_function_type == MATCH_CONDASSERT)      if (md->match_function_type == MATCH_CONDASSERT)
1652        {        {
1653        condassert = TRUE;        condassert = TRUE;
# Line 1567  for (;;) Line 1658  for (;;)
1658      do      do
1659        {        {
1660        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
1661          md->mark = save_mark;
1662        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);
1663        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1664          {          {
# Line 1593  for (;;) Line 1685  for (;;)
1685      back a number of characters, not bytes. */      back a number of characters, not bytes. */
1686    
1687      case OP_REVERSE:      case OP_REVERSE:
1688  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
1689      if (utf8)      if (utf)
1690        {        {
1691        i = GET(ecode, 1);        i = GET(ecode, 1);
1692        while (i-- > 0)        while (i-- > 0)
# Line 1625  for (;;) Line 1717  for (;;)
1717      function is able to force a failure. */      function is able to force a failure. */
1718    
1719      case OP_CALLOUT:      case OP_CALLOUT:
1720      if (pcre_callout != NULL)      if (PUBL(callout) != NULL)
1721        {        {
1722        pcre_callout_block cb;        PUBL(callout_block) cb;
1723        cb.version          = 2;   /* Version 1 of the callout block */        cb.version          = 2;   /* Version 1 of the callout block */
1724        cb.callout_number   = ecode[1];        cb.callout_number   = ecode[1];
1725        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
1726    #if defined COMPILE_PCRE8
1727        cb.subject          = (PCRE_SPTR)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
1728    #elif defined COMPILE_PCRE16
1729          cb.subject          = (PCRE_SPTR16)md->start_subject;
1730    #elif defined COMPILE_PCRE32
1731          cb.subject          = (PCRE_SPTR32)md->start_subject;
1732    #endif
1733        cb.subject_length   = (int)(md->end_subject - md->start_subject);        cb.subject_length   = (int)(md->end_subject - md->start_subject);
1734        cb.start_match      = (int)(mstart - md->start_subject);        cb.start_match      = (int)(mstart - md->start_subject);
1735        cb.current_position = (int)(eptr - md->start_subject);        cb.current_position = (int)(eptr - md->start_subject);
1736        cb.pattern_position = GET(ecode, 2);        cb.pattern_position = GET(ecode, 2);
1737        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
1738        cb.capture_top      = offset_top/2;        cb.capture_top      = offset_top/2;
1739        cb.capture_last     = md->capture_last;        cb.capture_last     = md->capture_last & CAPLMASK;
1740          /* Internal change requires this for API compatibility. */
1741          if (cb.capture_last == 0) cb.capture_last = -1;
1742        cb.callout_data     = md->callout_data;        cb.callout_data     = md->callout_data;
1743        cb.mark             = md->nomatch_mark;        cb.mark             = md->nomatch_mark;
1744        if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);        if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
1745        if (rrc < 0) RRETURN(rrc);        if (rrc < 0) RRETURN(rrc);
1746        }        }
1747      ecode += 2 + 2*LINK_SIZE;      ecode += 2 + 2*LINK_SIZE;
# Line 1667  for (;;) Line 1767  for (;;)
1767      case OP_RECURSE:      case OP_RECURSE:
1768        {        {
1769        recursion_info *ri;        recursion_info *ri;
1770        int recno;        unsigned int recno;
1771    
1772        callpat = md->start_code + GET(ecode, 1);        callpat = md->start_code + GET(ecode, 1);
1773        recno = (callpat == md->start_code)? 0 :        recno = (callpat == md->start_code)? 0 :
# Line 1684  for (;;) Line 1784  for (;;)
1784        /* Add to "recursing stack" */        /* Add to "recursing stack" */
1785    
1786        new_recursive.group_num = recno;        new_recursive.group_num = recno;
1787          new_recursive.saved_capture_last = md->capture_last;
1788        new_recursive.subject_position = eptr;        new_recursive.subject_position = eptr;
1789        new_recursive.prevrec = md->recursive;        new_recursive.prevrec = md->recursive;
1790        md->recursive = &new_recursive;        md->recursive = &new_recursive;
# Line 1700  for (;;) Line 1801  for (;;)
1801        else        else
1802          {          {
1803          new_recursive.offset_save =          new_recursive.offset_save =
1804            (int *)(pcre_malloc)(new_recursive.saved_max * sizeof(int));            (int *)(PUBL(malloc))(new_recursive.saved_max * sizeof(int));
1805          if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);          if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
1806          }          }
1807        memcpy(new_recursive.offset_save, md->offset_vector,        memcpy(new_recursive.offset_save, md->offset_vector,
1808              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
1809    
1810        /* OK, now we can do the recursion. After processing each alternative,        /* OK, now we can do the recursion. After processing each alternative,
1811        restore the offset data. If there were nested recursions, md->recursive        restore the offset data and the last captured value. If there were nested
1812        might be changed, so reset it before looping. */        recursions, md->recursive might be changed, so reset it before looping.
1813          */
1814    
1815        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));        DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
1816        cbegroup = (*callpat >= OP_SBRA);        cbegroup = (*callpat >= OP_SBRA);
1817        do        do
1818          {          {
1819          if (cbegroup) md->match_function_type = MATCH_CBEGROUP;          if (cbegroup) md->match_function_type = MATCH_CBEGROUP;
1820          RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top,          RMATCH(eptr, callpat + PRIV(OP_lengths)[*callpat], offset_top,
1821            md, eptrb, RM6);            md, eptrb, RM6);
1822          memcpy(md->offset_vector, new_recursive.offset_save,          memcpy(md->offset_vector, new_recursive.offset_save,
1823              new_recursive.saved_max * sizeof(int));              new_recursive.saved_max * sizeof(int));
1824            md->capture_last = new_recursive.saved_capture_last;
1825          md->recursive = new_recursive.prevrec;          md->recursive = new_recursive.prevrec;
1826          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)          if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
1827            {            {
1828            DPRINTF(("Recursion matched\n"));            DPRINTF(("Recursion matched\n"));
1829            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1830              (pcre_free)(new_recursive.offset_save);              (PUBL(free))(new_recursive.offset_save);
1831    
1832            /* Set where we got to in the subject, and reset the start in case            /* Set where we got to in the subject, and reset the start in case
1833            it was changed by \K. This *is* propagated back out of a recursion,            it was changed by \K. This *is* propagated back out of a recursion,
# Line 1735  for (;;) Line 1838  for (;;)
1838            goto RECURSION_MATCHED;        /* Exit loop; end processing */            goto RECURSION_MATCHED;        /* Exit loop; end processing */
1839            }            }
1840    
1841          /* PCRE does not allow THEN to escape beyond a recursion; it is treated          /* PCRE does not allow THEN or COMMIT to escape beyond a recursion; it
1842          as NOMATCH. */          is treated as NOMATCH. */
1843    
1844          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN &&
1845                     rrc != MATCH_COMMIT)
1846            {            {
1847            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1848            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
1849              (pcre_free)(new_recursive.offset_save);              (PUBL(free))(new_recursive.offset_save);
1850            RRETURN(rrc);            RRETURN(rrc);
1851            }            }
1852    
# Line 1754  for (;;) Line 1858  for (;;)
1858        DPRINTF(("Recursion didn't match\n"));        DPRINTF(("Recursion didn't match\n"));
1859        md->recursive = new_recursive.prevrec;        md->recursive = new_recursive.prevrec;
1860        if (new_recursive.offset_save != stacksave)        if (new_recursive.offset_save != stacksave)
1861          (pcre_free)(new_recursive.offset_save);          (PUBL(free))(new_recursive.offset_save);
1862        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
1863        }        }
1864    
# Line 1868  for (;;) Line 1972  for (;;)
1972    
1973        /* Deal with capturing */        /* Deal with capturing */
1974    
1975        md->capture_last = number;        md->capture_last = (md->capture_last & OVFLMASK) | number;
1976        if (offset >= md->offset_max) md->offset_overflow = TRUE; else        if (offset >= md->offset_max) md->capture_last |= OVFLBIT; else
1977          {          {
1978          /* If offset is greater than offset_top, it means that we are          /* If offset is greater than offset_top, it means that we are
1979          "skipping" a capturing group, and that group's offsets must be marked          "skipping" a capturing group, and that group's offsets must be marked
# Line 1949  for (;;) Line 2053  for (;;)
2053          }          }
2054        if (*prev >= OP_SBRA)    /* Could match an empty string */        if (*prev >= OP_SBRA)    /* Could match an empty string */
2055          {          {
         md->match_function_type = MATCH_CBEGROUP;  
2056          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
2057          RRETURN(rrc);          RRETURN(rrc);
2058          }          }
# Line 1958  for (;;) Line 2061  for (;;)
2061        }        }
2062      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
2063        {        {
       if (*prev >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;  
2064        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
2065        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
2066        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
# Line 2015  for (;;) Line 2117  for (;;)
2117    
2118      case OP_DOLLM:      case OP_DOLLM:
2119      if (eptr < md->end_subject)      if (eptr < md->end_subject)
2120        { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }        {
2121          if (!IS_NEWLINE(eptr))
2122            {
2123            if (md->partial != 0 &&
2124                eptr + 1 >= md->end_subject &&
2125                NLBLOCK->nltype == NLTYPE_FIXED &&
2126                NLBLOCK->nllen == 2 &&
2127                RAWUCHARTEST(eptr) == NLBLOCK->nl[0])
2128              {
2129              md->hitend = TRUE;
2130              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2131              }
2132            RRETURN(MATCH_NOMATCH);
2133            }
2134          }
2135      else      else
2136        {        {
2137        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) RRETURN(MATCH_NOMATCH);
# Line 2047  for (;;) Line 2163  for (;;)
2163      ASSERT_NL_OR_EOS:      ASSERT_NL_OR_EOS:
2164      if (eptr < md->end_subject &&      if (eptr < md->end_subject &&
2165          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
2166          {
2167          if (md->partial != 0 &&
2168              eptr + 1 >= md->end_subject &&
2169              NLBLOCK->nltype == NLTYPE_FIXED &&
2170              NLBLOCK->nllen == 2 &&
2171              RAWUCHARTEST(eptr) == NLBLOCK->nl[0])
2172            {
2173            md->hitend = TRUE;
2174            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2175            }
2176        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2177          }
2178    
2179      /* Either at end of string or \n before end. */      /* Either at end of string or \n before end. */
2180    
# Line 2066  for (;;) Line 2193  for (;;)
2193        be "non-word" characters. Remember the earliest consulted character for        be "non-word" characters. Remember the earliest consulted character for
2194        partial matching. */        partial matching. */
2195    
2196  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
2197        if (utf8)        if (utf)
2198          {          {
2199          /* Get status of previous character */          /* Get status of previous character */
2200    
2201          if (eptr == md->start_subject) prev_is_word = FALSE; else          if (eptr == md->start_subject) prev_is_word = FALSE; else
2202            {            {
2203            USPTR lastptr = eptr - 1;            PCRE_PUCHAR lastptr = eptr - 1;
2204            while((*lastptr & 0xc0) == 0x80) lastptr--;            BACKCHAR(lastptr);
2205            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;            if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
2206            GETCHAR(c, lastptr);            GETCHAR(c, lastptr);
2207  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
# Line 2139  for (;;) Line 2266  for (;;)
2266              }              }
2267            else            else
2268  #endif  #endif
2269            prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0);            prev_is_word = MAX_255(eptr[-1])
2270                && ((md->ctypes[eptr[-1]] & ctype_word) != 0);
2271            }            }
2272    
2273          /* Get status of next character */          /* Get status of next character */
# Line 2162  for (;;) Line 2290  for (;;)
2290            }            }
2291          else          else
2292  #endif  #endif
2293          cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0);          cur_is_word = MAX_255(*eptr)
2294              && ((md->ctypes[*eptr] & ctype_word) != 0);
2295          }          }
2296    
2297        /* Now see if the situation is what we want */        /* Now see if the situation is what we want */
# Line 2173  for (;;) Line 2302  for (;;)
2302        }        }
2303      break;      break;
2304    
2305      /* Match a single character type; inline for speed */      /* Match any single character type except newline; have to take care with
2306        CRLF newlines and partial matching. */
2307    
2308      case OP_ANY:      case OP_ANY:
2309      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
2310        if (md->partial != 0 &&
2311            eptr + 1 >= md->end_subject &&
2312            NLBLOCK->nltype == NLTYPE_FIXED &&
2313            NLBLOCK->nllen == 2 &&
2314            RAWUCHARTEST(eptr) == NLBLOCK->nl[0])
2315          {
2316          md->hitend = TRUE;
2317          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2318          }
2319    
2320      /* Fall through */      /* Fall through */
2321    
2322        /* Match any single character whatsoever. */
2323    
2324      case OP_ALLANY:      case OP_ALLANY:
2325      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
2326        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
# Line 2186  for (;;) Line 2328  for (;;)
2328        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2329        }        }
2330      eptr++;      eptr++;
2331      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  #ifdef SUPPORT_UTF
2332        if (utf) ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
2333    #endif
2334      ecode++;      ecode++;
2335      break;      break;
2336    
# Line 2211  for (;;) Line 2355  for (;;)
2355        }        }
2356      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2357      if (      if (
2358  #ifdef SUPPORT_UTF8  #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2359         c < 256 &&         c < 256 &&
2360  #endif  #endif
2361         (md->ctypes[c] & ctype_digit) != 0         (md->ctypes[c] & ctype_digit) != 0
# Line 2228  for (;;) Line 2372  for (;;)
2372        }        }
2373      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2374      if (      if (
2375  #ifdef SUPPORT_UTF8  #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2376         c >= 256 ||         c > 255 ||
2377  #endif  #endif
2378         (md->ctypes[c] & ctype_digit) == 0         (md->ctypes[c] & ctype_digit) == 0
2379         )         )
# Line 2245  for (;;) Line 2389  for (;;)
2389        }        }
2390      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2391      if (      if (
2392  #ifdef SUPPORT_UTF8  #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2393         c < 256 &&         c < 256 &&
2394  #endif  #endif
2395         (md->ctypes[c] & ctype_space) != 0         (md->ctypes[c] & ctype_space) != 0
# Line 2262  for (;;) Line 2406  for (;;)
2406        }        }
2407      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2408      if (      if (
2409  #ifdef SUPPORT_UTF8  #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2410         c >= 256 ||         c > 255 ||
2411  #endif  #endif
2412         (md->ctypes[c] & ctype_space) == 0         (md->ctypes[c] & ctype_space) == 0
2413         )         )
# Line 2279  for (;;) Line 2423  for (;;)
2423        }        }
2424      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2425      if (      if (
2426  #ifdef SUPPORT_UTF8  #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2427         c < 256 &&         c < 256 &&
2428  #endif  #endif
2429         (md->ctypes[c] & ctype_word) != 0         (md->ctypes[c] & ctype_word) != 0
# Line 2296  for (;;) Line 2440  for (;;)
2440        }        }
2441      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2442      if (      if (
2443  #ifdef SUPPORT_UTF8  #if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
2444         c >= 256 ||         c > 255 ||
2445  #endif  #endif
2446         (md->ctypes[c] & ctype_word) == 0         (md->ctypes[c] & ctype_word) == 0
2447         )         )
# Line 2316  for (;;) Line 2460  for (;;)
2460        {        {
2461        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2462    
2463        case 0x000d:        case CHAR_CR:
2464        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr >= md->end_subject)
2465            {
2466            SCHECK_PARTIAL();
2467            }
2468          else if (RAWUCHARTEST(eptr) == CHAR_LF) eptr++;
2469        break;        break;
2470    
2471        case 0x000a:        case CHAR_LF:
2472        break;        break;
2473    
2474        case 0x000b:        case CHAR_VT:
2475        case 0x000c:        case CHAR_FF:
2476        case 0x0085:        case CHAR_NEL:
2477    #ifndef EBCDIC
2478        case 0x2028:        case 0x2028:
2479        case 0x2029:        case 0x2029:
2480    #endif  /* Not EBCDIC */
2481        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2482        break;        break;
2483        }        }
# Line 2343  for (;;) Line 2493  for (;;)
2493      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2494      switch(c)      switch(c)
2495        {        {
2496          HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
2497        default: break;        default: break;
       case 0x09:      /* HT */  
       case 0x20:      /* SPACE */  
       case 0xa0:      /* NBSP */  
       case 0x1680:    /* OGHAM SPACE MARK */  
       case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
       case 0x2000:    /* EN QUAD */  
       case 0x2001:    /* EM QUAD */  
       case 0x2002:    /* EN SPACE */  
       case 0x2003:    /* EM SPACE */  
       case 0x2004:    /* THREE-PER-EM SPACE */  
       case 0x2005:    /* FOUR-PER-EM SPACE */  
       case 0x2006:    /* SIX-PER-EM SPACE */  
       case 0x2007:    /* FIGURE SPACE */  
       case 0x2008:    /* PUNCTUATION SPACE */  
       case 0x2009:    /* THIN SPACE */  
       case 0x200A:    /* HAIR SPACE */  
       case 0x202f:    /* NARROW NO-BREAK SPACE */  
       case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
       case 0x3000:    /* IDEOGRAPHIC SPACE */  
       RRETURN(MATCH_NOMATCH);  
2498        }        }
2499      ecode++;      ecode++;
2500      break;      break;
# Line 2377  for (;;) Line 2508  for (;;)
2508      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2509      switch(c)      switch(c)
2510        {        {
2511          HSPACE_CASES: break;  /* Byte and multibyte cases */
2512        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
       case 0x09:      /* HT */  
       case 0x20:      /* SPACE */  
       case 0xa0:      /* NBSP */  
       case 0x1680:    /* OGHAM SPACE MARK */  
       case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
       case 0x2000:    /* EN QUAD */  
       case 0x2001:    /* EM QUAD */  
       case 0x2002:    /* EN SPACE */  
       case 0x2003:    /* EM SPACE */  
       case 0x2004:    /* THREE-PER-EM SPACE */  
       case 0x2005:    /* FOUR-PER-EM SPACE */  
       case 0x2006:    /* SIX-PER-EM SPACE */  
       case 0x2007:    /* FIGURE SPACE */  
       case 0x2008:    /* PUNCTUATION SPACE */  
       case 0x2009:    /* THIN SPACE */  
       case 0x200A:    /* HAIR SPACE */  
       case 0x202f:    /* NARROW NO-BREAK SPACE */  
       case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
       case 0x3000:    /* IDEOGRAPHIC SPACE */  
       break;  
2513        }        }
2514      ecode++;      ecode++;
2515      break;      break;
# Line 2411  for (;;) Line 2523  for (;;)
2523      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2524      switch(c)      switch(c)
2525        {        {
2526          VSPACE_CASES: RRETURN(MATCH_NOMATCH);
2527        default: break;        default: break;
       case 0x0a:      /* LF */  
       case 0x0b:      /* VT */  
       case 0x0c:      /* FF */  
       case 0x0d:      /* CR */  
       case 0x85:      /* NEL */  
       case 0x2028:    /* LINE SEPARATOR */  
       case 0x2029:    /* PARAGRAPH SEPARATOR */  
       RRETURN(MATCH_NOMATCH);  
2528        }        }
2529      ecode++;      ecode++;
2530      break;      break;
# Line 2433  for (;;) Line 2538  for (;;)
2538      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2539      switch(c)      switch(c)
2540        {        {
2541          VSPACE_CASES: break;
2542        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
       case 0x0a:      /* LF */  
       case 0x0b:      /* VT */  
       case 0x0c:      /* FF */  
       case 0x0d:      /* CR */  
       case 0x85:      /* NEL */  
       case 0x2028:    /* LINE SEPARATOR */  
       case 0x2029:    /* PARAGRAPH SEPARATOR */  
       break;  
2543        }        }
2544      ecode++;      ecode++;
2545      break;      break;
# Line 2459  for (;;) Line 2557  for (;;)
2557        }        }
2558      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2559        {        {
2560          const pcre_uint32 *cp;
2561        const ucd_record *prop = GET_UCD(c);        const ucd_record *prop = GET_UCD(c);
2562    
2563        switch(ecode[1])        switch(ecode[1])
# Line 2475  for (;;) Line 2574  for (;;)
2574          break;          break;
2575    
2576          case PT_GC:          case PT_GC:
2577          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))          if ((ecode[2] != PRIV(ucp_gentype)[prop->chartype]) == (op == OP_PROP))
2578            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2579          break;          break;
2580    
# Line 2492  for (;;) Line 2591  for (;;)
2591          /* These are specials */          /* These are specials */
2592    
2593          case PT_ALNUM:          case PT_ALNUM:
2594          if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||          if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
2595               _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP))               PRIV(ucp_gentype)[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
2596            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2597          break;          break;
2598    
2599          case PT_SPACE:    /* Perl space */          case PT_SPACE:    /* Perl space */
2600          if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||          if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
2601               c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)               c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR)
2602                 == (op == OP_NOTPROP))                 == (op == OP_NOTPROP))
2603            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2604          break;          break;
2605    
2606          case PT_PXSPACE:  /* POSIX space */          case PT_PXSPACE:  /* POSIX space */
2607          if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z ||          if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z ||
2608               c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||               c == CHAR_HT || c == CHAR_NL || c == CHAR_VT ||
2609               c == CHAR_FF || c == CHAR_CR)               c == CHAR_FF || c == CHAR_CR)
2610                 == (op == OP_NOTPROP))                 == (op == OP_NOTPROP))
# Line 2513  for (;;) Line 2612  for (;;)
2612          break;          break;
2613    
2614          case PT_WORD:          case PT_WORD:
2615          if ((_pcre_ucp_gentype[prop->chartype] == ucp_L ||          if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
2616               _pcre_ucp_gentype[prop->chartype] == ucp_N ||               PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
2617               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2618            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2619          break;          break;
2620    
2621            case PT_CLIST:
2622            cp = PRIV(ucd_caseless_sets) + ecode[2];
2623            for (;;)
2624              {
2625              if (c < *cp)
2626                { if (op == OP_PROP) { RRETURN(MATCH_NOMATCH); } else break; }
2627              if (c == *cp++)
2628                { if (op == OP_PROP) break; else { RRETURN(MATCH_NOMATCH); } }
2629              }
2630            break;
2631    
2632            case PT_UCNC:
2633            if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
2634                 c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
2635                 c >= 0xe000) == (op == OP_NOTPROP))
2636              RRETURN(MATCH_NOMATCH);
2637            break;
2638    
2639          /* This should never occur */          /* This should never occur */
2640    
2641          default:          default:
# Line 2538  for (;;) Line 2655  for (;;)
2655        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2656        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2657        }        }
2658      GETCHARINCTEST(c, eptr);      else
     if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
     while (eptr < md->end_subject)  
2659        {        {
2660        int len = 1;        int lgb, rgb;
2661        if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }        GETCHARINCTEST(c, eptr);
2662        if (UCD_CATEGORY(c) != ucp_M) break;        lgb = UCD_GRAPHBREAK(c);
2663        eptr += len;        while (eptr < md->end_subject)
2664            {
2665            int len = 1;
2666            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2667            rgb = UCD_GRAPHBREAK(c);
2668            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2669            lgb = rgb;
2670            eptr += len;
2671            }
2672        }        }
2673        CHECK_PARTIAL();
2674      ecode++;      ecode++;
2675      break;      break;
2676  #endif  #endif  /* SUPPORT_UCP */
2677    
2678    
2679      /* Match a back reference, possibly repeatedly. Look past the end of the      /* Match a back reference, possibly repeatedly. Look past the end of the
# Line 2564  for (;;) Line 2688  for (;;)
2688      case OP_REFI:      case OP_REFI:
2689      caseless = op == OP_REFI;      caseless = op == OP_REFI;
2690      offset = GET2(ecode, 1) << 1;               /* Doubled ref number */      offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
2691      ecode += 3;      ecode += 1 + IMM2_SIZE;
2692    
2693      /* If the reference is unset, there are two possibilities:      /* If the reference is unset, there are two possibilities:
2694    
# Line 2604  for (;;) Line 2728  for (;;)
2728        case OP_CRMINRANGE:        case OP_CRMINRANGE:
2729        minimize = (*ecode == OP_CRMINRANGE);        minimize = (*ecode == OP_CRMINRANGE);
2730        min = GET2(ecode, 1);        min = GET2(ecode, 1);
2731        max = GET2(ecode, 3);        max = GET2(ecode, 1 + IMM2_SIZE);
2732        if (max == 0) max = INT_MAX;        if (max == 0) max = INT_MAX;
2733        ecode += 5;        ecode += 1 + 2 * IMM2_SIZE;
2734        break;        break;
2735    
2736        default:               /* No repeat follows */        default:               /* No repeat follows */
2737        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2738          {          {
2739            if (length == -2) eptr = md->end_subject;   /* Partial match */
2740          CHECK_PARTIAL();          CHECK_PARTIAL();
2741          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2742          }          }
# Line 2620  for (;;) Line 2745  for (;;)
2745        }        }
2746    
2747      /* Handle repeated back references. If the length of the reference is      /* Handle repeated back references. If the length of the reference is
2748      zero, just continue with the main loop. */      zero, just continue with the main loop. If the length is negative, it
2749        means the reference is unset in non-Java-compatible mode. If the minimum is
2750        zero, we can continue at the same level without recursion. For any other
2751        minimum, carrying on will result in NOMATCH. */
2752    
2753      if (length == 0) continue;      if (length == 0) continue;
2754        if (length < 0 && min == 0) continue;
2755    
2756      /* First, ensure the minimum number of matches are present. We get back      /* First, ensure the minimum number of matches are present. We get back
2757      the length of the reference string explicitly rather than passing the      the length of the reference string explicitly rather than passing the
# Line 2633  for (;;) Line 2762  for (;;)
2762        int slength;        int slength;
2763        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2764          {          {
2765            if (slength == -2) eptr = md->end_subject;   /* Partial match */
2766          CHECK_PARTIAL();          CHECK_PARTIAL();
2767          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2768          }          }
# Line 2656  for (;;) Line 2786  for (;;)
2786          if (fi >= max) RRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2787          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2788            {            {
2789              if (slength == -2) eptr = md->end_subject;   /* Partial match */
2790            CHECK_PARTIAL();            CHECK_PARTIAL();
2791            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2792            }            }
# Line 2674  for (;;) Line 2805  for (;;)
2805          int slength;          int slength;
2806          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2807            {            {
2808            CHECK_PARTIAL();            /* Can't use CHECK_PARTIAL because we don't want to update eptr in
2809              the soft partial matching case. */
2810    
2811              if (slength == -2 && md->partial != 0 &&
2812                  md->end_subject > md->start_used_ptr)
2813                {
2814                md->hitend = TRUE;
2815                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2816                }
2817            break;            break;
2818            }            }
2819          eptr += slength;          eptr += slength;
2820          }          }
2821    
2822        while (eptr >= pp)        while (eptr >= pp)
2823          {          {
2824          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
# Line 2703  for (;;) Line 2843  for (;;)
2843      case OP_NCLASS:      case OP_NCLASS:
2844      case OP_CLASS:      case OP_CLASS:
2845        {        {
2846          /* The data variable is saved across frames, so the byte map needs to
2847          be stored there. */
2848    #define BYTE_MAP ((pcre_uint8 *)data)
2849        data = ecode + 1;                /* Save for matching */        data = ecode + 1;                /* Save for matching */
2850        ecode += 33;                     /* Advance past the item */        ecode += 1 + (32 / sizeof(pcre_uchar)); /* Advance past the item */
2851    
2852        switch (*ecode)        switch (*ecode)
2853          {          {
# Line 2725  for (;;) Line 2868  for (;;)
2868          case OP_CRMINRANGE:          case OP_CRMINRANGE:
2869          minimize = (*ecode == OP_CRMINRANGE);          minimize = (*ecode == OP_CRMINRANGE);
2870          min = GET2(ecode, 1);          min = GET2(ecode, 1);
2871          max = GET2(ecode, 3);          max = GET2(ecode, 1 + IMM2_SIZE);
2872          if (max == 0) max = INT_MAX;          if (max == 0) max = INT_MAX;
2873          ecode += 5;          ecode += 1 + 2 * IMM2_SIZE;
2874          break;          break;
2875    
2876          default:               /* No repeat follows */          default:               /* No repeat follows */
# Line 2737  for (;;) Line 2880  for (;;)
2880    
2881        /* First, ensure the minimum number of matches are present. */        /* First, ensure the minimum number of matches are present. */
2882    
2883  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
2884        /* UTF-8 mode */        if (utf)
       if (utf8)  
2885          {          {
2886          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2887            {            {
# Line 2754  for (;;) Line 2896  for (;;)
2896              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2897              }              }
2898            else            else
2899              {              if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
             if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);  
             }  
2900            }            }
2901          }          }
2902        else        else
2903  #endif  #endif
2904        /* Not UTF-8 mode */        /* Not UTF mode */
2905          {          {
2906          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2907            {            {
# Line 2771  for (;;) Line 2911  for (;;)
2911              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2912              }              }
2913            c = *eptr++;            c = *eptr++;
2914            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);  #ifndef COMPILE_PCRE8
2915              if (c > 255)
2916                {
2917                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2918                }
2919              else
2920    #endif
2921                if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2922            }            }
2923          }          }
2924    
# Line 2785  for (;;) Line 2932  for (;;)
2932    
2933        if (minimize)        if (minimize)
2934          {          {
2935  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
2936          /* UTF-8 mode */          if (utf)
         if (utf8)  
2937            {            {
2938            for (fi = min;; fi++)            for (fi = min;; fi++)
2939              {              {
# Line 2805  for (;;) Line 2951  for (;;)
2951                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);                if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2952                }                }
2953              else              else
2954                {                if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
               if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);  
               }  
2955              }              }
2956            }            }
2957          else          else
2958  #endif  #endif
2959          /* Not UTF-8 mode */          /* Not UTF mode */
2960            {            {
2961            for (fi = min;; fi++)            for (fi = min;; fi++)
2962              {              {
# Line 2825  for (;;) Line 2969  for (;;)
2969                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2970                }                }
2971              c = *eptr++;              c = *eptr++;
2972              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);  #ifndef COMPILE_PCRE8
2973                if (c > 255)
2974                  {
2975                  if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
2976                  }
2977                else
2978    #endif
2979                  if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
2980              }              }
2981            }            }
2982          /* Control never gets here */          /* Control never gets here */
# Line 2837  for (;;) Line 2988  for (;;)
2988          {          {
2989          pp = eptr;          pp = eptr;
2990    
2991  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
2992          /* UTF-8 mode */          if (utf)
         if (utf8)  
2993            {            {
2994            for (i = min; i < max; i++)            for (i = min; i < max; i++)
2995              {              {
# Line 2855  for (;;) Line 3005  for (;;)
3005                if (op == OP_CLASS) break;                if (op == OP_CLASS) break;
3006                }                }
3007              else              else
3008                {                if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
               if ((data[c/8] & (1 << (c&7))) == 0) break;  
               }  
3009              eptr += len;              eptr += len;
3010              }              }
3011            for (;;)            for (;;)
# Line 2870  for (;;) Line 3018  for (;;)
3018            }            }
3019          else          else
3020  #endif  #endif
3021            /* Not UTF-8 mode */            /* Not UTF mode */
3022            {            {
3023            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3024              {              {
# Line 2880  for (;;) Line 3028  for (;;)
3028                break;                break;
3029                }                }
3030              c = *eptr;              c = *eptr;
3031              if ((data[c/8] & (1 << (c&7))) == 0) break;  #ifndef COMPILE_PCRE8
3032                if (c > 255)
3033                  {
3034                  if (op == OP_CLASS) break;
3035                  }
3036                else
3037    #endif
3038                  if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
3039              eptr++;              eptr++;
3040              }              }
3041            while (eptr >= pp)            while (eptr >= pp)
# Line 2893  for (;;) Line 3048  for (;;)
3048    
3049          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3050          }          }
3051    #undef BYTE_MAP
3052        }        }
3053      /* Control never gets here */      /* Control never gets here */
3054    
# Line 2901  for (;;) Line 3057  for (;;)
3057      when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8      when UTF-8 mode mode is supported. Nevertheless, we may not be in UTF-8
3058      mode, because Unicode properties are supported in non-UTF-8 mode. */      mode, because Unicode properties are supported in non-UTF-8 mode. */
3059    
3060  #ifdef SUPPORT_UTF8  #if defined SUPPORT_UTF || !defined COMPILE_PCRE8
3061      case OP_XCLASS:      case OP_XCLASS:
3062        {        {
3063        data = ecode + 1 + LINK_SIZE;                /* Save for matching */        data = ecode + 1 + LINK_SIZE;                /* Save for matching */
# Line 2926  for (;;) Line 3082  for (;;)
3082          case OP_CRMINRANGE:          case OP_CRMINRANGE:
3083          minimize = (*ecode == OP_CRMINRANGE);          minimize = (*ecode == OP_CRMINRANGE);
3084          min = GET2(ecode, 1);          min = GET2(ecode, 1);
3085          max = GET2(ecode, 3);          max = GET2(ecode, 1 + IMM2_SIZE);
3086          if (max == 0) max = INT_MAX;          if (max == 0) max = INT_MAX;
3087          ecode += 5;          ecode += 1 + 2 * IMM2_SIZE;
3088          break;          break;
3089    
3090          default:               /* No repeat follows */          default:               /* No repeat follows */
# Line 2946  for (;;) Line 3102  for (;;)
3102            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3103            }            }
3104          GETCHARINCTEST(c, eptr);          GETCHARINCTEST(c, eptr);
3105          if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);          if (!PRIV(xclass)(c, data, utf)) RRETURN(MATCH_NOMATCH);
3106          }          }
3107    
3108        /* If max == min we can continue with the main loop without the        /* If max == min we can continue with the main loop without the
# Line 2970  for (;;) Line 3126  for (;;)
3126              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3127              }              }
3128            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3129            if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH);            if (!PRIV(xclass)(c, data, utf)) RRETURN(MATCH_NOMATCH);
3130            }            }
3131          /* Control never gets here */          /* Control never gets here */
3132          }          }
# Line 2988  for (;;) Line 3144  for (;;)
3144              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3145              break;              break;
3146              }              }
3147    #ifdef SUPPORT_UTF
3148            GETCHARLENTEST(c, eptr, len);            GETCHARLENTEST(c, eptr, len);
3149            if (!_pcre_xclass(c, data)) break;  #else
3150              c = *eptr;
3151    #endif
3152              if (!PRIV(xclass)(c, data, utf)) break;
3153            eptr += len;            eptr += len;
3154            }            }
3155          for(;;)          for(;;)
# Line 2997  for (;;) Line 3157  for (;;)
3157            RMATCH(eptr, ecode, offset_top, md, eptrb, RM21);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM21);
3158            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3159            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3160            if (utf8) BACKCHAR(eptr);  #ifdef SUPPORT_UTF
3161              if (utf) BACKCHAR(eptr);
3162    #endif
3163            }            }
3164          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3165          }          }
# Line 3009  for (;;) Line 3171  for (;;)
3171      /* Match a single character, casefully */      /* Match a single character, casefully */
3172    
3173      case OP_CHAR:      case OP_CHAR:
3174  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
3175      if (utf8)      if (utf)
3176        {        {
3177        length = 1;        length = 1;
3178        ecode++;        ecode++;
# Line 3020  for (;;) Line 3182  for (;;)
3182          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
3183          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3184          }          }
3185        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != RAWUCHARINC(eptr)) RRETURN(MATCH_NOMATCH);
3186        }        }
3187      else      else
3188  #endif  #endif
3189        /* Not UTF mode */
     /* Non-UTF-8 mode */  
3190        {        {
3191        if (md->end_subject - eptr < 1)        if (md->end_subject - eptr < 1)
3192          {          {
# Line 3047  for (;;) Line 3208  for (;;)
3208        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3209        }        }
3210    
3211  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
3212      if (utf8)      if (utf)
3213        {        {
3214        length = 1;        length = 1;
3215        ecode++;        ecode++;
# Line 3061  for (;;) Line 3222  for (;;)
3222    
3223        if (fc < 128)        if (fc < 128)
3224          {          {
3225          if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          pcre_uint32 cc = RAWUCHAR(eptr);
3226            if (md->lcc[fc] != TABLE_GET(cc, md->lcc, cc)) RRETURN(MATCH_NOMATCH);
3227            ecode++;
3228            eptr++;
3229          }          }
3230    
3231        /* Otherwise we must pick up the subject character. Note that we cannot        /* Otherwise we must pick up the subject character. Note that we cannot
# Line 3070  for (;;) Line 3234  for (;;)
3234    
3235        else        else
3236          {          {
3237          unsigned int dc;          pcre_uint32 dc;
3238          GETCHARINC(dc, eptr);          GETCHARINC(dc, eptr);
3239          ecode += length;          ecode += length;
3240    
# Line 3087  for (;;) Line 3251  for (;;)
3251          }          }
3252        }        }
3253      else      else
3254  #endif   /* SUPPORT_UTF8 */  #endif   /* SUPPORT_UTF */
3255    
3256      /* Non-UTF-8 mode */      /* Not UTF mode */
3257        {        {
3258        if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);        if (TABLE_GET(ecode[1], md->lcc, ecode[1])
3259              != TABLE_GET(*eptr, md->lcc, *eptr)) RRETURN(MATCH_NOMATCH);
3260          eptr++;
3261        ecode += 2;        ecode += 2;
3262        }        }
3263      break;      break;
# Line 3101  for (;;) Line 3267  for (;;)
3267      case OP_EXACT:      case OP_EXACT:
3268      case OP_EXACTI:      case OP_EXACTI:
3269      min = max = GET2(ecode, 1);      min = max = GET2(ecode, 1);
3270      ecode += 3;      ecode += 1 + IMM2_SIZE;
3271      goto REPEATCHAR;      goto REPEATCHAR;
3272    
3273      case OP_POSUPTO:      case OP_POSUPTO:
# Line 3116  for (;;) Line 3282  for (;;)
3282      min = 0;      min = 0;
3283      max = GET2(ecode, 1);      max = GET2(ecode, 1);
3284      minimize = *ecode == OP_MINUPTO || *ecode == OP_MINUPTOI;      minimize = *ecode == OP_MINUPTO || *ecode == OP_MINUPTOI;
3285      ecode += 3;      ecode += 1 + IMM2_SIZE;
3286      goto REPEATCHAR;      goto REPEATCHAR;
3287    
3288      case OP_POSSTAR:      case OP_POSSTAR:
# Line 3164  for (;;) Line 3330  for (;;)
3330      /* Common code for all repeated single-character matches. */      /* Common code for all repeated single-character matches. */
3331    
3332      REPEATCHAR:      REPEATCHAR:
3333  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
3334      if (utf8)      if (utf)
3335        {        {
3336        length = 1;        length = 1;
3337        charptr = ecode;        charptr = ecode;
# Line 3178  for (;;) Line 3344  for (;;)
3344        if (length > 1)        if (length > 1)
3345          {          {
3346  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3347          unsigned int othercase;          pcre_uint32 othercase;
3348          if (op >= OP_STARI &&     /* Caseless */          if (op >= OP_STARI &&     /* Caseless */
3349              (othercase = UCD_OTHERCASE(fc)) != fc)              (othercase = UCD_OTHERCASE(fc)) != fc)
3350            oclength = _pcre_ord2utf8(othercase, occhars);            oclength = PRIV(ord2utf)(othercase, occhars);
3351          else oclength = 0;          else oclength = 0;
3352  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
3353    
3354          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3355            {            {
3356            if (eptr <= md->end_subject - length &&            if (eptr <= md->end_subject - length &&
3357              memcmp(eptr, charptr, length) == 0) eptr += length;              memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
3358  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3359            else if (oclength > 0 &&            else if (oclength > 0 &&
3360                     eptr <= md->end_subject - oclength &&                     eptr <= md->end_subject - oclength &&
3361                     memcmp(eptr, occhars, oclength) == 0) eptr += oclength;                     memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
3362  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
3363            else            else
3364              {              {
# Line 3211  for (;;) Line 3377  for (;;)
3377              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3378              if (fi >= max) RRETURN(MATCH_NOMATCH);              if (fi >= max) RRETURN(MATCH_NOMATCH);
3379              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
3380                memcmp(eptr, charptr, length) == 0) eptr += length;                memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
3381  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3382              else if (oclength > 0 &&              else if (oclength > 0 &&
3383                       eptr <= md->end_subject - oclength &&                       eptr <= md->end_subject - oclength &&
3384                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;                       memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
3385  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
3386              else              else
3387                {                {
# Line 3232  for (;;) Line 3398  for (;;)
3398            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3399              {              {
3400              if (eptr <= md->end_subject - length &&              if (eptr <= md->end_subject - length &&
3401                  memcmp(eptr, charptr, length) == 0) eptr += length;                  memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
3402  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3403              else if (oclength > 0 &&              else if (oclength > 0 &&
3404                       eptr <= md->end_subject - oclength &&                       eptr <= md->end_subject - oclength &&
3405                       memcmp(eptr, occhars, oclength) == 0) eptr += oclength;                       memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
3406  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
3407              else              else
3408                {                {
# Line 3268  for (;;) Line 3434  for (;;)
3434        value of fc will always be < 128. */        value of fc will always be < 128. */
3435        }        }
3436      else      else
3437  #endif  /* SUPPORT_UTF8 */  #endif  /* SUPPORT_UTF */
3438          /* When not in UTF-8 mode, load a single-byte character. */
3439      /* When not in UTF-8 mode, load a single-byte character. */        fc = *ecode++;
3440    
3441      fc = *ecode++;      /* The value of fc at this point is always one character, though we may
3442        or may not be in UTF mode. The code is duplicated for the caseless and
     /* The value of fc at this point is always less than 256, though we may or  
     may not be in UTF-8 mode. The code is duplicated for the caseless and  
3443      caseful cases, for speed, since matching characters is likely to be quite      caseful cases, for speed, since matching characters is likely to be quite
3444      common. First, ensure the minimum number of matches are present. If min =      common. First, ensure the minimum number of matches are present. If min =
3445      max, continue at the same level without recursing. Otherwise, if      max, continue at the same level without recursing. Otherwise, if
# Line 3284  for (;;) Line 3448  for (;;)
3448      maximizing, find the maximum number of characters and work backwards. */      maximizing, find the maximum number of characters and work backwards. */
3449    
3450      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3451        max, eptr));        max, (char *)eptr));
3452    
3453      if (op >= OP_STARI)  /* Caseless */      if (op >= OP_STARI)  /* Caseless */
3454        {        {
3455        fc = md->lcc[fc];  #ifdef COMPILE_PCRE8
3456          /* fc must be < 128 if UTF is enabled. */
3457          foc = md->fcc[fc];
3458    #else
3459    #ifdef SUPPORT_UTF
3460    #ifdef SUPPORT_UCP
3461          if (utf && fc > 127)
3462            foc = UCD_OTHERCASE(fc);
3463    #else
3464          if (utf && fc > 127)
3465            foc = fc;
3466    #endif /* SUPPORT_UCP */
3467          else
3468    #endif /* SUPPORT_UTF */
3469            foc = TABLE_GET(fc, md->fcc, fc);
3470    #endif /* COMPILE_PCRE8 */
3471    
3472        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
3473          {          {
3474            pcre_uint32 cc;                 /* Faster than pcre_uchar */
3475          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
3476            {            {
3477            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3478            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3479            }            }
3480          if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);          cc = RAWUCHARTEST(eptr);
3481            if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
3482            eptr++;
3483          }          }
3484        if (min == max) continue;        if (min == max) continue;
3485        if (minimize)        if (minimize)
3486          {          {
3487          for (fi = min;; fi++)          for (fi = min;; fi++)
3488            {            {
3489              pcre_uint32 cc;               /* Faster than pcre_uchar */
3490            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
3491            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3492            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
# Line 3311  for (;;) Line 3495  for (;;)
3495              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3496              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3497              }              }
3498            if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            cc = RAWUCHARTEST(eptr);
3499              if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
3500              eptr++;
3501            }            }
3502          /* Control never gets here */          /* Control never gets here */
3503          }          }
# Line 3320  for (;;) Line 3506  for (;;)
3506          pp = eptr;          pp = eptr;
3507          for (i = min; i < max; i++)          for (i = min; i < max; i++)
3508            {            {
3509              pcre_uint32 cc;               /* Faster than pcre_uchar */
3510            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3511              {              {
3512              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3513              break;              break;
3514              }              }
3515            if (fc != md->lcc[*eptr]) break;            cc = RAWUCHARTEST(eptr);
3516              if (fc != cc && foc != cc) break;
3517            eptr++;            eptr++;
3518            }            }
3519    
# Line 3353  for (;;) Line 3541  for (;;)
3541            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3542            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3543            }            }
3544          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != RAWUCHARINCTEST(eptr)) RRETURN(MATCH_NOMATCH);
3545          }          }
3546    
3547        if (min == max) continue;        if (min == max) continue;
# Line 3370  for (;;) Line 3558  for (;;)
3558              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3559              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3560              }              }
3561            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != RAWUCHARINCTEST(eptr)) RRETURN(MATCH_NOMATCH);
3562            }            }
3563          /* Control never gets here */          /* Control never gets here */
3564          }          }
# Line 3384  for (;;) Line 3572  for (;;)
3572              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3573              break;              break;
3574              }              }
3575            if (fc != *eptr) break;            if (fc != RAWUCHARTEST(eptr)) break;
3576            eptr++;            eptr++;
3577            }            }
3578          if (possessive) continue;          if (possessive) continue;
# Line 3410  for (;;) Line 3598  for (;;)
3598        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3599        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3600        }        }
3601      ecode++;  #ifdef SUPPORT_UTF
3602      GETCHARINCTEST(c, eptr);      if (utf)
     if (op == OP_NOTI)         /* The caseless case */  
3603        {        {
3604  #ifdef SUPPORT_UTF8        register pcre_uint32 ch, och;
3605        if (c < 256)  
3606  #endif        ecode++;
3607        c = md->lcc[c];        GETCHARINC(ch, ecode);
3608        if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);        GETCHARINC(c, eptr);
3609    
3610          if (op == OP_NOT)
3611            {
3612            if (ch == c) RRETURN(MATCH_NOMATCH);
3613            }
3614          else
3615            {
3616    #ifdef SUPPORT_UCP
3617            if (ch > 127)
3618              och = UCD_OTHERCASE(ch);
3619    #else
3620            if (ch > 127)
3621              och = ch;
3622    #endif /* SUPPORT_UCP */
3623            else
3624              och = TABLE_GET(ch, md->fcc, ch);
3625            if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
3626            }
3627        }        }
3628      else    /* Caseful */      else
3629    #endif
3630        {        {
3631        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        register pcre_uint32 ch = ecode[1];
3632          c = *eptr++;
3633          if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3634            RRETURN(MATCH_NOMATCH);
3635          ecode += 2;
3636        }        }
3637      break;      break;
3638    
# Line 3436  for (;;) Line 3646  for (;;)
3646      case OP_NOTEXACT:      case OP_NOTEXACT:
3647      case OP_NOTEXACTI:      case OP_NOTEXACTI:
3648      min = max = GET2(ecode, 1);      min = max = GET2(ecode, 1);
3649      ecode += 3;      ecode += 1 + IMM2_SIZE;
3650      goto REPEATNOTCHAR;      goto REPEATNOTCHAR;
3651    
3652      case OP_NOTUPTO:      case OP_NOTUPTO:
# Line 3446  for (;;) Line 3656  for (;;)
3656      min = 0;      min = 0;
3657      max = GET2(ecode, 1);      max = GET2(ecode, 1);
3658      minimize = *ecode == OP_NOTMINUPTO || *ecode == OP_NOTMINUPTOI;      minimize = *ecode == OP_NOTMINUPTO || *ecode == OP_NOTMINUPTOI;
3659      ecode += 3;      ecode += 1 + IMM2_SIZE;
3660      goto REPEATNOTCHAR;      goto REPEATNOTCHAR;
3661    
3662      case OP_NOTPOSSTAR:      case OP_NOTPOSSTAR:
# Line 3478  for (;;) Line 3688  for (;;)
3688      possessive = TRUE;      possessive = TRUE;
3689      min = 0;      min = 0;
3690      max = GET2(ecode, 1);      max = GET2(ecode, 1);
3691      ecode += 3;      ecode += 1 + IMM2_SIZE;
3692      goto REPEATNOTCHAR;      goto REPEATNOTCHAR;
3693    
3694      case OP_NOTSTAR:      case OP_NOTSTAR:
# Line 3502  for (;;) Line 3712  for (;;)
3712      /* Common code for all repeated single-byte matches. */      /* Common code for all repeated single-byte matches. */
3713    
3714      REPEATNOTCHAR:      REPEATNOTCHAR:
3715      fc = *ecode++;      GETCHARINCTEST(fc, ecode);
3716    
3717      /* The code is duplicated for the caseless and caseful cases, for speed,      /* The code is duplicated for the caseless and caseful cases, for speed,
3718      since matching characters is likely to be quite common. First, ensure the      since matching characters is likely to be quite common. First, ensure the
# Line 3513  for (;;) Line 3723  for (;;)
3723      characters and work backwards. */      characters and work backwards. */
3724    
3725      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3726        max, eptr));        max, (char *)eptr));
3727    
3728      if (op >= OP_NOTSTARI)     /* Caseless */      if (op >= OP_NOTSTARI)     /* Caseless */
3729        {        {
3730        fc = md->lcc[fc];  #ifdef SUPPORT_UTF
3731    #ifdef SUPPORT_UCP
3732          if (utf && fc > 127)
3733            foc = UCD_OTHERCASE(fc);
3734    #else
3735          if (utf && fc > 127)
3736            foc = fc;
3737    #endif /* SUPPORT_UCP */
3738          else
3739    #endif /* SUPPORT_UTF */
3740            foc = TABLE_GET(fc, md->fcc, fc);
3741    
3742  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
3743        /* UTF-8 mode */        if (utf)
       if (utf8)  
3744          {          {
3745          register unsigned int d;          register pcre_uint32 d;
3746          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3747            {            {
3748            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
# Line 3532  for (;;) Line 3751  for (;;)
3751              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3752              }              }
3753            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3754            if (d < 256) d = md->lcc[d];            if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
           if (fc == d) RRETURN(MATCH_NOMATCH);  
3755            }            }
3756          }          }
3757        else        else
3758  #endif  #endif
3759          /* Not UTF mode */
       /* Not UTF-8 mode */  
3760          {          {
3761          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3762            {            {
# Line 3548  for (;;) Line 3765  for (;;)
3765              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3766              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3767              }              }
3768            if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);            if (fc == *eptr || foc == *eptr) RRETURN(MATCH_NOMATCH);
3769              eptr++;
3770            }            }
3771          }          }
3772    
# Line 3556  for (;;) Line 3774  for (;;)
3774    
3775        if (minimize)        if (minimize)
3776          {          {
3777  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
3778          /* UTF-8 mode */          if (utf)
         if (utf8)  
3779            {            {
3780            register unsigned int d;            register pcre_uint32 d;
3781            for (fi = min;; fi++)            for (fi = min;; fi++)
3782              {              {
3783              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
# Line 3572  for (;;) Line 3789  for (;;)
3789                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3790                }                }
3791              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3792              if (d < 256) d = md->lcc[d];              if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
             if (fc == d) RRETURN(MATCH_NOMATCH);  
3793              }              }
3794            }            }
3795          else          else
3796  #endif  #endif
3797          /* Not UTF-8 mode */          /* Not UTF mode */
3798            {            {
3799            for (fi = min;; fi++)            for (fi = min;; fi++)
3800              {              {
# Line 3590  for (;;) Line 3806  for (;;)
3806                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3807                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3808                }                }
3809              if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);              if (fc == *eptr || foc == *eptr) RRETURN(MATCH_NOMATCH);
3810                eptr++;
3811              }              }
3812            }            }
3813          /* Control never gets here */          /* Control never gets here */
# Line 3602  for (;;) Line 3819  for (;;)
3819          {          {
3820          pp = eptr;          pp = eptr;
3821    
3822  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
3823          /* UTF-8 mode */          if (utf)
         if (utf8)  
3824            {            {
3825            register unsigned int d;            register pcre_uint32 d;
3826            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3827              {              {
3828              int len = 1;              int len = 1;
# Line 3616  for (;;) Line 3832  for (;;)
3832                break;                break;
3833                }                }
3834              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3835              if (d < 256) d = md->lcc[d];              if (fc == d || (unsigned int)foc == d) break;
             if (fc == d) break;  
3836              eptr += len;              eptr += len;
3837              }              }
3838          if (possessive) continue;            if (possessive) continue;
3839          for(;;)            for(;;)
3840              {              {
3841              RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);
3842              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
# Line 3631  for (;;) Line 3846  for (;;)
3846            }            }
3847          else          else
3848  #endif  #endif
3849          /* Not UTF-8 mode */          /* Not UTF mode */
3850            {            {
3851            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3852              {              {
# Line 3640  for (;;) Line 3855  for (;;)
3855                SCHECK_PARTIAL();                SCHECK_PARTIAL();
3856                break;                break;
3857                }                }
3858              if (fc == md->lcc[*eptr]) break;              if (fc == *eptr || foc == *eptr) break;
3859              eptr++;              eptr++;
3860              }              }
3861            if (possessive) continue;            if (possessive) continue;
# Line 3661  for (;;) Line 3876  for (;;)
3876    
3877      else      else
3878        {        {
3879  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
3880        /* UTF-8 mode */        if (utf)
       if (utf8)  
3881          {          {
3882          register unsigned int d;          register pcre_uint32 d;
3883          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3884            {            {
3885            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
# Line 3679  for (;;) Line 3893  for (;;)
3893          }          }
3894        else        else
3895  #endif  #endif
3896        /* Not UTF-8 mode */        /* Not UTF mode */
3897          {          {
3898          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3899            {            {
# Line 3696  for (;;) Line 3910  for (;;)
3910    
3911        if (minimize)        if (minimize)
3912          {          {
3913  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
3914          /* UTF-8 mode */          if (utf)
         if (utf8)  
3915            {            {
3916            register unsigned int d;            register pcre_uint32 d;
3917            for (fi = min;; fi++)            for (fi = min;; fi++)
3918              {              {
3919              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
# Line 3717  for (;;) Line 3930  for (;;)
3930            }            }
3931          else          else
3932  #endif  #endif
3933          /* Not UTF-8 mode */          /* Not UTF mode */
3934            {            {
3935            for (fi = min;; fi++)            for (fi = min;; fi++)
3936              {              {
# Line 3741  for (;;) Line 3954  for (;;)
3954          {          {
3955          pp = eptr;          pp = eptr;
3956    
3957  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
3958          /* UTF-8 mode */          if (utf)
         if (utf8)  
3959            {            {
3960            register unsigned int d;            register pcre_uint32 d;
3961            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3962              {              {
3963              int len = 1;              int len = 1;
# Line 3769  for (;;) Line 3981  for (;;)
3981            }            }
3982          else          else
3983  #endif  #endif
3984          /* Not UTF-8 mode */          /* Not UTF mode */
3985            {            {
3986            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3987              {              {
# Line 3802  for (;;) Line 4014  for (;;)
4014      case OP_TYPEEXACT:      case OP_TYPEEXACT:
4015      min = max = GET2(ecode, 1);      min = max = GET2(ecode, 1);
4016      minimize = TRUE;      minimize = TRUE;
4017      ecode += 3;      ecode += 1 + IMM2_SIZE;
4018      goto REPEATTYPE;      goto REPEATTYPE;
4019    
4020      case OP_TYPEUPTO:      case OP_TYPEUPTO:
# Line 3810  for (;;) Line 4022  for (;;)
4022      min = 0;      min = 0;
4023      max = GET2(ecode, 1);      max = GET2(ecode, 1);
4024      minimize = *ecode == OP_TYPEMINUPTO;      minimize = *ecode == OP_TYPEMINUPTO;
4025      ecode += 3;      ecode += 1 + IMM2_SIZE;
4026      goto REPEATTYPE;      goto REPEATTYPE;
4027    
4028      case OP_TYPEPOSSTAR:      case OP_TYPEPOSSTAR:
# Line 3838  for (;;) Line 4050  for (;;)
4050      possessive = TRUE;      possessive = TRUE;
4051      min = 0;      min = 0;
4052      max = GET2(ecode, 1);      max = GET2(ecode, 1);
4053      ecode += 3;      ecode += 1 + IMM2_SIZE;
4054      goto REPEATTYPE;      goto REPEATTYPE;
4055    
4056      case OP_TYPESTAR:      case OP_TYPESTAR:
# Line 4021  for (;;) Line 4233  for (;;)
4233              }              }
4234            break;            break;
4235    
4236              case PT_CLIST:
4237              for (i = 1; i <= min; i++)
4238                {
4239                const pcre_uint32 *cp;
4240                if (eptr >= md->end_subject)
4241                  {
4242                  SCHECK_PARTIAL();
4243                  RRETURN(MATCH_NOMATCH);
4244                  }
4245                GETCHARINCTEST(c, eptr);
4246                cp = PRIV(ucd_caseless_sets) + prop_value;
4247                for (;;)
4248                  {
4249                  if (c < *cp)
4250                    { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4251                  if (c == *cp++)
4252                    { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4253                  }
4254                }
4255              break;
4256    
4257              case PT_UCNC:
4258              for (i = 1; i <= min; i++)
4259                {
4260                if (eptr >= md->end_subject)
4261                  {
4262                  SCHECK_PARTIAL();
4263                  RRETURN(MATCH_NOMATCH);
4264                  }
4265                GETCHARINCTEST(c, eptr);
4266                if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
4267                     c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
4268                     c >= 0xe000) == prop_fail_result)
4269                  RRETURN(MATCH_NOMATCH);
4270                }
4271              break;
4272    
4273            /* This should not occur */            /* This should not occur */
4274    
4275            default:            default:
# Line 4040  for (;;) Line 4289  for (;;)
4289              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4290              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4291              }              }
4292            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4293              {              {
4294              int len = 1;              int lgb, rgb;
4295              if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4296              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4297              eptr += len;             while (eptr < md->end_subject)
4298                  {
4299                  int len = 1;
4300                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4301                  rgb = UCD_GRAPHBREAK(c);
4302                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4303                  lgb = rgb;
4304                  eptr += len;
4305                  }
4306              }              }
4307              CHECK_PARTIAL();
4308            }            }
4309          }          }
4310    
# Line 4057  for (;;) Line 4313  for (;;)
4313    
4314  /* Handle all other cases when the coding is UTF-8 */  /* Handle all other cases when the coding is UTF-8 */
4315    
4316  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
4317        if (utf8) switch(ctype)        if (utf) switch(ctype)
4318          {          {
4319          case OP_ANY:          case OP_ANY:
4320          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
# Line 4069  for (;;) Line 4325  for (;;)
4325              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4326              }              }
4327            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4328              if (md->partial != 0 &&
4329                  eptr + 1 >= md->end_subject &&
4330                  NLBLOCK->nltype == NLTYPE_FIXED &&
4331                  NLBLOCK->nllen == 2 &&
4332                  RAWUCHAR(eptr) == NLBLOCK->nl[0])
4333                {
4334                md->hitend = TRUE;
4335                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4336                }
4337            eptr++;            eptr++;
4338            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4339            }            }
4340          break;          break;
4341    
# Line 4083  for (;;) Line 4348  for (;;)
4348              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4349              }              }
4350            eptr++;            eptr++;
4351            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4352            }            }
4353          break;          break;
4354    
# Line 4105  for (;;) Line 4370  for (;;)
4370              {              {
4371              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4372    
4373              case 0x000d:              case CHAR_CR:
4374              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && RAWUCHAR(eptr) == CHAR_LF) eptr++;
4375              break;              break;
4376    
4377              case 0x000a:              case CHAR_LF:
4378              break;              break;
4379    
4380              case 0x000b:              case CHAR_VT:
4381              case 0x000c:              case CHAR_FF:
4382              case 0x0085:              case CHAR_NEL:
4383    #ifndef EBCDIC
4384              case 0x2028:              case 0x2028:
4385              case 0x2029:              case 0x2029:
4386    #endif  /* Not EBCDIC */
4387              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4388              break;              break;
4389              }              }
# Line 4134  for (;;) Line 4401  for (;;)
4401            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4402            switch(c)            switch(c)
4403              {              {
4404                HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
4405              default: break;              default: break;
             case 0x09:      /* HT */  
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
             case 0x1680:    /* OGHAM SPACE MARK */  
             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
             case 0x2000:    /* EN QUAD */  
             case 0x2001:    /* EM QUAD */  
             case 0x2002:    /* EN SPACE */  
             case 0x2003:    /* EM SPACE */  
             case 0x2004:    /* THREE-PER-EM SPACE */  
             case 0x2005:    /* FOUR-PER-EM SPACE */  
             case 0x2006:    /* SIX-PER-EM SPACE */  
             case 0x2007:    /* FIGURE SPACE */  
             case 0x2008:    /* PUNCTUATION SPACE */  
             case 0x2009:    /* THIN SPACE */  
             case 0x200A:    /* HAIR SPACE */  
             case 0x202f:    /* NARROW NO-BREAK SPACE */  
             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
             case 0x3000:    /* IDEOGRAPHIC SPACE */  
             RRETURN(MATCH_NOMATCH);  
4406              }              }
4407            }            }
4408          break;          break;
# Line 4170  for (;;) Line 4418  for (;;)
4418            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4419            switch(c)            switch(c)
4420              {              {
4421                HSPACE_CASES: break;  /* Byte and multibyte cases */
4422              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
             case 0x09:      /* HT */  
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
             case 0x1680:    /* OGHAM SPACE MARK */  
             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
             case 0x2000:    /* EN QUAD */  
             case 0x2001:    /* EM QUAD */  
             case 0x2002:    /* EN SPACE */  
             case 0x2003:    /* EM SPACE */  
             case 0x2004:    /* THREE-PER-EM SPACE */  
             case 0x2005:    /* FOUR-PER-EM SPACE */  
             case 0x2006:    /* SIX-PER-EM SPACE */  
             case 0x2007:    /* FIGURE SPACE */  
             case 0x2008:    /* PUNCTUATION SPACE */  
             case 0x2009:    /* THIN SPACE */  
             case 0x200A:    /* HAIR SPACE */  
             case 0x202f:    /* NARROW NO-BREAK SPACE */  
             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
             case 0x3000:    /* IDEOGRAPHIC SPACE */  
             break;  
4423              }              }
4424            }            }
4425          break;          break;
# Line 4206  for (;;) Line 4435  for (;;)
4435            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4436            switch(c)            switch(c)
4437              {              {
4438                VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4439              default: break;              default: break;
             case 0x0a:      /* LF */  
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
             case 0x2028:    /* LINE SEPARATOR */  
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
             RRETURN(MATCH_NOMATCH);  
4440              }              }
4441            }            }
4442          break;          break;
# Line 4230  for (;;) Line 4452  for (;;)
4452            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4453            switch(c)            switch(c)
4454              {              {
4455                VSPACE_CASES: break;
4456              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
             case 0x0a:      /* LF */  
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
             case 0x2028:    /* LINE SEPARATOR */  
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
             break;  
4457              }              }
4458            }            }
4459          break;          break;
# Line 4260  for (;;) Line 4475  for (;;)
4475          case OP_DIGIT:          case OP_DIGIT:
4476          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4477            {            {
4478              pcre_uint32 cc;
4479            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4480              {              {
4481              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4482              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4483              }              }
4484            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)            cc = RAWUCHAR(eptr);
4485              if (cc >= 128 || (md->ctypes[cc] & ctype_digit) == 0)
4486              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4487              eptr++;
4488            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
4489            }            }
4490          break;          break;
# Line 4274  for (;;) Line 4492  for (;;)
4492          case OP_NOT_WHITESPACE:          case OP_NOT_WHITESPACE:
4493          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4494            {            {
4495              pcre_uint32 cc;
4496            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4497              {              {
4498              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4499              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4500              }              }
4501            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            cc = RAWUCHAR(eptr);
4502              if (cc < 128 && (md->ctypes[cc] & ctype_space) != 0)
4503              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4504            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            eptr++;
4505              ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4506            }            }
4507          break;          break;
4508    
4509          case OP_WHITESPACE:          case OP_WHITESPACE:
4510          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4511            {            {
4512              pcre_uint32 cc;
4513            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4514              {              {
4515              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4516              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4517              }              }
4518            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)            cc = RAWUCHAR(eptr);
4519              if (cc >= 128 || (md->ctypes[cc] & ctype_space) == 0)
4520              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4521              eptr++;
4522            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
4523            }            }
4524          break;          break;
# Line 4302  for (;;) Line 4526  for (;;)
4526          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
4527          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4528            {            {
4529              pcre_uint32 cc;
4530            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4531              {              {
4532              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4533              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4534              }              }
4535            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)            cc = RAWUCHAR(eptr);
4536              if (cc < 128 && (md->ctypes[cc] & ctype_word) != 0)
4537              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4538            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);            eptr++;
4539              ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4540            }            }
4541          break;          break;
4542    
4543          case OP_WORDCHAR:          case OP_WORDCHAR:
4544          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4545            {            {
4546              pcre_uint32 cc;
4547            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4548              {              {
4549              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4550              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4551              }              }
4552            if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)            cc = RAWUCHAR(eptr);
4553              if (cc >= 128 || (md->ctypes[cc] & ctype_word) == 0)
4554              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4555              eptr++;
4556            /* No need to skip more bytes - we know it's a 1-byte character */            /* No need to skip more bytes - we know it's a 1-byte character */
4557            }            }
4558          break;          break;
# Line 4332  for (;;) Line 4562  for (;;)
4562          }  /* End switch(ctype) */          }  /* End switch(ctype) */
4563    
4564        else        else
4565  #endif     /* SUPPORT_UTF8 */  #endif     /* SUPPORT_UTF */
4566    
4567        /* Code for the non-UTF-8 case for minimum matching of operators other        /* Code for the non-UTF-8 case for minimum matching of operators other
4568        than OP_PROP and OP_NOTPROP. */        than OP_PROP and OP_NOTPROP. */
# Line 4348  for (;;) Line 4578  for (;;)
4578              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4579              }              }
4580            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4581              if (md->partial != 0 &&
4582                  eptr + 1 >= md->end_subject &&
4583                  NLBLOCK->nltype == NLTYPE_FIXED &&
4584                  NLBLOCK->nllen == 2 &&
4585                  *eptr == NLBLOCK->nl[0])
4586                {
4587                md->hitend = TRUE;
4588                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4589                }
4590            eptr++;            eptr++;
4591            }            }
4592          break;          break;
# Line 4382  for (;;) Line 4621  for (;;)
4621              {              {
4622              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4623    
4624              case 0x000d:              case CHAR_CR:
4625              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4626              break;              break;
4627    
4628              case 0x000a:              case CHAR_LF:
4629              break;              break;
4630    
4631              case 0x000b:              case CHAR_VT:
4632              case 0x000c:              case CHAR_FF:
4633              case 0x0085:              case CHAR_NEL:
4634    #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4635                case 0x2028:
4636                case 0x2029:
4637    #endif
4638              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4639              break;              break;
4640              }              }
# Line 4409  for (;;) Line 4652  for (;;)
4652            switch(*eptr++)            switch(*eptr++)
4653              {              {
4654              default: break;              default: break;
4655              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
4656              case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4657              case 0xa0:      /* NBSP */              HSPACE_MULTIBYTE_CASES:
4658    #endif
4659              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4660              }              }
4661            }            }
# Line 4428  for (;;) Line 4672  for (;;)
4672            switch(*eptr++)            switch(*eptr++)
4673              {              {
4674              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4675              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
4676              case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4677              case 0xa0:      /* NBSP */              HSPACE_MULTIBYTE_CASES:
4678    #endif
4679              break;              break;
4680              }              }
4681            }            }
# Line 4446  for (;;) Line 4691  for (;;)
4691              }              }
4692            switch(*eptr++)            switch(*eptr++)
4693              {              {
4694              default: break;              VSPACE_BYTE_CASES:
4695              case 0x0a:      /* LF */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4696              case 0x0b:      /* VT */              VSPACE_MULTIBYTE_CASES:
4697              case 0x0c:      /* FF */  #endif
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
4698              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4699                default: break;
4700              }              }
4701            }            }
4702          break;          break;
# Line 4468  for (;;) Line 4712  for (;;)
4712            switch(*eptr++)            switch(*eptr++)
4713              {              {
4714              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4715              case 0x0a:      /* LF */              VSPACE_BYTE_CASES:
4716              case 0x0b:      /* VT */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4717              case 0x0c:      /* FF */              VSPACE_MULTIBYTE_CASES:
4718              case 0x0d:      /* CR */  #endif
             case 0x85:      /* NEL */  
4719              break;              break;
4720              }              }
4721            }            }
# Line 4486  for (;;) Line 4729  for (;;)
4729              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4730              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4731              }              }
4732            if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);            if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_digit) != 0)
4733                RRETURN(MATCH_NOMATCH);
4734              eptr++;
4735            }            }
4736          break;          break;
4737    
# Line 4498  for (;;) Line 4743  for (;;)
4743              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4744              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4745              }              }
4746            if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);            if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_digit) == 0)
4747                RRETURN(MATCH_NOMATCH);
4748              eptr++;
4749            }            }
4750          break;          break;
4751    
# Line 4510  for (;;) Line 4757  for (;;)
4757              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4758              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4759              }              }
4760            if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);            if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_space) != 0)
4761                RRETURN(MATCH_NOMATCH);
4762              eptr++;
4763            }            }
4764          break;          break;
4765    
# Line 4522  for (;;) Line 4771  for (;;)
4771              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4772              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4773              }              }
4774            if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);            if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_space) == 0)
4775                RRETURN(MATCH_NOMATCH);
4776              eptr++;
4777            }            }
4778          break;          break;
4779    
# Line 4534  for (;;) Line 4785  for (;;)
4785              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4786              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4787              }              }
4788            if ((md->ctypes[*eptr++] & ctype_word) != 0)            if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_word) != 0)
4789              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4790              eptr++;
4791            }            }
4792          break;          break;
4793    
# Line 4547  for (;;) Line 4799  for (;;)
4799              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4800              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4801              }              }
4802            if ((md->ctypes[*eptr++] & ctype_word) == 0)            if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_word) == 0)
4803              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4804              eptr++;
4805            }            }
4806          break;          break;
4807    
# Line 4739  for (;;) Line 4992  for (;;)
4992              }              }
4993            /* Control never gets here */            /* Control never gets here */
4994    
4995            /* This should never occur */            case PT_CLIST:
4996              for (fi = min;; fi++)
4997                {
4998                const pcre_uint32 *cp;
4999                RMATCH(eptr, ecode, offset_top, md, eptrb, RM67);
5000                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5001                if (fi >= max) RRETURN(MATCH_NOMATCH);
5002                if (eptr >= md->end_subject)
5003                  {
5004                  SCHECK_PARTIAL();
5005                  RRETURN(MATCH_NOMATCH);
5006                  }
5007                GETCHARINCTEST(c, eptr);
5008                cp = PRIV(ucd_caseless_sets) + prop_value;
5009                for (;;)
5010                  {
5011                  if (c < *cp)
5012                    { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
5013                  if (c == *cp++)
5014                    { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
5015                  }
5016                }
5017              /* Control never gets here */
5018    
5019              case PT_UCNC:
5020              for (fi = min;; fi++)
5021                {
5022                RMATCH(eptr, ecode, offset_top, md, eptrb, RM68);
5023                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5024                if (fi >= max) RRETURN(MATCH_NOMATCH);
5025                if (eptr >= md->end_subject)
5026                  {
5027                  SCHECK_PARTIAL();
5028                  RRETURN(MATCH_NOMATCH);
5029                  }
5030                GETCHARINCTEST(c, eptr);
5031                if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
5032                     c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
5033                     c >= 0xe000) == prop_fail_result)
5034                  RRETURN(MATCH_NOMATCH);
5035                }
5036              /* Control never gets here */
5037    
5038              /* This should never occur */
5039            default:            default:
5040            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
5041            }            }
# Line 4761  for (;;) Line 5056  for (;;)
5056              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5057              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
5058              }              }
5059            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
5060              {              {
5061              int len = 1;              int lgb, rgb;
5062              if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
5063              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
5064              eptr += len;              while (eptr < md->end_subject)
5065                  {
5066                  int len = 1;
5067                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5068                  rgb = UCD_GRAPHBREAK(c);
5069                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5070                  lgb = rgb;
5071                  eptr += len;
5072                  }
5073              }              }
5074              CHECK_PARTIAL();
5075            }            }
5076          }          }
5077        else        else
5078  #endif     /* SUPPORT_UCP */  #endif     /* SUPPORT_UCP */
5079    
5080  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
5081        /* UTF-8 mode */        if (utf)
       if (utf8)  
5082          {          {
5083          for (fi = min;; fi++)          for (fi = min;; fi++)
5084            {            {
# Line 4794  for (;;) Line 5095  for (;;)
5095            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
5096            switch(ctype)            switch(ctype)
5097              {              {
5098              case OP_ANY:        /* This is the non-NL case */              case OP_ANY:               /* This is the non-NL case */
5099                if (md->partial != 0 &&    /* Take care with CRLF partial */
5100                    eptr >= md->end_subject &&
5101                    NLBLOCK->nltype == NLTYPE_FIXED &&
5102                    NLBLOCK->nllen == 2 &&
5103                    c == NLBLOCK->nl[0])
5104                  {
5105                  md->hitend = TRUE;
5106                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5107                  }
5108                break;
5109    
5110              case OP_ALLANY:              case OP_ALLANY:
5111              case OP_ANYBYTE:              case OP_ANYBYTE:
5112              break;              break;
# Line 4803  for (;;) Line 5115  for (;;)
5115              switch(c)              switch(c)
5116                {                {
5117                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5118                case 0x000d:                case CHAR_CR:
5119                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && RAWUCHAR(eptr) == CHAR_LF) eptr++;
5120                break;                break;
5121                case 0x000a:  
5122                  case CHAR_LF:
5123                break;                break;
5124    
5125                case 0x000b:                case CHAR_VT:
5126                case 0x000c:                case CHAR_FF:
5127                case 0x0085:                case CHAR_NEL:
5128    #ifndef EBCDIC
5129                case 0x2028:                case 0x2028:
5130                case 0x2029:                case 0x2029:
5131    #endif  /* Not EBCDIC */
5132                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5133                break;                break;
5134                }                }
# Line 4822  for (;;) Line 5137  for (;;)
5137              case OP_NOT_HSPACE:              case OP_NOT_HSPACE:
5138              switch(c)              switch(c)
5139                {                {
5140                  HSPACE_CASES: RRETURN(MATCH_NOMATCH);
5141                default: break;                default: break;
               case 0x09:      /* HT */  
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
               case 0x1680:    /* OGHAM SPACE MARK */  
               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
               case 0x2000:    /* EN QUAD */  
               case 0x2001:    /* EM QUAD */  
               case 0x2002:    /* EN SPACE */  
               case 0x2003:    /* EM SPACE */  
               case 0x2004:    /* THREE-PER-EM SPACE */  
               case 0x2005:    /* FOUR-PER-EM SPACE */  
               case 0x2006:    /* SIX-PER-EM SPACE */  
               case 0x2007:    /* FIGURE SPACE */  
               case 0x2008:    /* PUNCTUATION SPACE */  
               case 0x2009:    /* THIN SPACE */  
               case 0x200A:    /* HAIR SPACE */  
               case 0x202f:    /* NARROW NO-BREAK SPACE */  
               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
               case 0x3000:    /* IDEOGRAPHIC SPACE */  
               RRETURN(MATCH_NOMATCH);  
5142                }                }
5143              break;              break;
5144    
5145              case OP_HSPACE:              case OP_HSPACE:
5146              switch(c)              switch(c)
5147                {                {
5148                  HSPACE_CASES: break;
5149                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
               case 0x09:      /* HT */  
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
               case 0x1680:    /* OGHAM SPACE MARK */  
               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
               case 0x2000:    /* EN QUAD */  
               case 0x2001:    /* EM QUAD */  
               case 0x2002:    /* EN SPACE */  
               case 0x2003:    /* EM SPACE */  
               case 0x2004:    /* THREE-PER-EM SPACE */  
               case 0x2005:    /* FOUR-PER-EM SPACE */  
               case 0x2006:    /* SIX-PER-EM SPACE */  
               case 0x2007:    /* FIGURE SPACE */  
               case 0x2008:    /* PUNCTUATION SPACE */  
               case 0x2009:    /* THIN SPACE */  
               case 0x200A:    /* HAIR SPACE */  
               case 0x202f:    /* NARROW NO-BREAK SPACE */  
               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
               case 0x3000:    /* IDEOGRAPHIC SPACE */  
               break;  
5150                }                }
5151              break;              break;
5152    
5153              case OP_NOT_VSPACE:              case OP_NOT_VSPACE:
5154              switch(c)              switch(c)
5155                {                {
5156                  VSPACE_CASES: RRETURN(MATCH_NOMATCH);
5157                default: break;                default: break;
               case 0x0a:      /* LF */  
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
               case 0x2028:    /* LINE SEPARATOR */  
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
               RRETURN(MATCH_NOMATCH);  
5158                }                }
5159              break;              break;
5160    
5161              case OP_VSPACE:              case OP_VSPACE:
5162              switch(c)              switch(c)
5163                {                {
5164                  VSPACE_CASES: break;
5165                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
               case 0x0a:      /* LF */  
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
               case 0x2028:    /* LINE SEPARATOR */  
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
               break;  
5166                }                }
5167              break;              break;
5168    
# Line 4919  for (;;) Line 5182  for (;;)
5182              break;              break;
5183    
5184              case OP_WHITESPACE:              case OP_WHITESPACE:
5185              if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)              if (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
5186                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5187              break;              break;
5188    
# Line 4940  for (;;) Line 5203  for (;;)
5203          }          }
5204        else        else
5205  #endif  #endif
5206        /* Not UTF-8 mode */        /* Not UTF mode */
5207          {          {
5208          for (fi = min;; fi++)          for (fi = min;; fi++)
5209            {            {
# Line 4957  for (;;) Line 5220  for (;;)
5220            c = *eptr++;            c = *eptr++;
5221            switch(ctype)            switch(ctype)
5222              {              {
5223              case OP_ANY:     /* This is the non-NL case */              case OP_ANY:               /* This is the non-NL case */
5224                if (md->partial != 0 &&    /* Take care with CRLF partial */
5225                    eptr >= md->end_subject &&
5226                    NLBLOCK->nltype == NLTYPE_FIXED &&
5227                    NLBLOCK->nllen == 2 &&
5228                    c == NLBLOCK->nl[0])
5229                  {
5230                  md->hitend = TRUE;
5231                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5232                  }
5233                break;
5234    
5235              case OP_ALLANY:              case OP_ALLANY:
5236              case OP_ANYBYTE:              case OP_ANYBYTE:
5237              break;              break;
# Line 4966  for (;;) Line 5240  for (;;)
5240              switch(c)              switch(c)
5241                {                {
5242                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5243                case 0x000d:                case CHAR_CR:
5244                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5245                break;                break;
5246    
5247                case 0x000a:                case CHAR_LF:
5248                break;                break;
5249    
5250                case 0x000b:                case CHAR_VT:
5251                case 0x000c:                case CHAR_FF:
5252                case 0x0085:                case CHAR_NEL:
5253    #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5254                  case 0x2028:
5255                  case 0x2029:
5256    #endif
5257                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5258                break;                break;
5259                }                }
# Line 4985  for (;;) Line 5263  for (;;)
5263              switch(c)              switch(c)
5264                {                {
5265                default: break;                default: break;
5266                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
5267                case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5268                case 0xa0:      /* NBSP */                HSPACE_MULTIBYTE_CASES:
5269    #endif
5270                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5271                }                }
5272              break;              break;
# Line 4996  for (;;) Line 5275  for (;;)
5275              switch(c)              switch(c)
5276                {                {
5277                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5278                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
5279                case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5280                case 0xa0:      /* NBSP */                HSPACE_MULTIBYTE_CASES:
5281    #endif
5282                break;                break;
5283                }                }
5284              break;              break;
# Line 5007  for (;;) Line 5287  for (;;)
5287              switch(c)              switch(c)
5288                {                {
5289                default: break;                default: break;
5290                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
5291                case 0x0b:      /* VT */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5292                case 0x0c:      /* FF */                VSPACE_MULTIBYTE_CASES:
5293                case 0x0d:      /* CR */  #endif
               case 0x85:      /* NEL */  
5294                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5295                }                }
5296              break;              break;
# Line 5020  for (;;) Line 5299  for (;;)
5299              switch(c)              switch(c)
5300                {                {
5301                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5302                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
5303                case 0x0b:      /* VT */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5304                case 0x0c:      /* FF */                VSPACE_MULTIBYTE_CASES:
5305                case 0x0d:      /* CR */  #endif
               case 0x85:      /* NEL */  
5306                break;                break;
5307                }                }
5308              break;              break;
5309    
5310              case OP_NOT_DIGIT:              case OP_NOT_DIGIT:
5311              if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);              if (MAX_255(c) && (md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
5312              break;              break;
5313    
5314              case OP_DIGIT:              case OP_DIGIT:
5315              if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);              if (!MAX_255(c) || (md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
5316              break;              break;
5317    
5318              case OP_NOT_WHITESPACE:              case OP_NOT_WHITESPACE:
5319              if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);              if (MAX_255(c) && (md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
5320              break;              break;
5321    
5322              case OP_WHITESPACE:              case OP_WHITESPACE:
5323              if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);              if (!MAX_255(c) || (md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
5324              break;              break;
5325    
5326              case OP_NOT_WORDCHAR:              case OP_NOT_WORDCHAR:
5327              if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);              if (MAX_255(c) && (md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
5328              break;              break;
5329    
5330              case OP_WORDCHAR:              case OP_WORDCHAR:
5331              if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);              if (!MAX_255(c) || (md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
5332              break;              break;
5333    
5334              default:              default:
# Line 5227  for (;;) Line 5505  for (;;)
5505              }              }
5506            break;            break;
5507    
5508              case PT_CLIST:
5509              for (i = min; i < max; i++)
5510                {
5511                const pcre_uint32 *cp;
5512                int len = 1;
5513                if (eptr >= md->end_subject)
5514                  {
5515                  SCHECK_PARTIAL();
5516                  break;
5517                  }
5518                GETCHARLENTEST(c, eptr, len);
5519                cp = PRIV(ucd_caseless_sets) + prop_value;
5520                for (;;)
5521                  {
5522                  if (c < *cp)
5523                    { if (prop_fail_result) break; else goto GOT_MAX; }
5524                  if (c == *cp++)
5525                    { if (prop_fail_result) goto GOT_MAX; else break; }
5526                  }
5527                eptr += len;
5528                }
5529              GOT_MAX:
5530              break;
5531    
5532              case PT_UCNC:
5533              for (i = min; i < max; i++)
5534                {
5535                int len = 1;
5536                if (eptr >= md->end_subject)
5537                  {
5538                  SCHECK_PARTIAL();
5539                  break;
5540                  }
5541                GETCHARLENTEST(c, eptr, len);
5542                if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
5543                     c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
5544                     c >= 0xe000) == prop_fail_result)
5545                  break;
5546                eptr += len;
5547                }
5548              break;
5549    
5550            default:            default:
5551            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
5552            }            }
# Line 5239  for (;;) Line 5559  for (;;)
5559            RMATCH(eptr, ecode, offset_top, md, eptrb, RM44);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM44);
5560            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5561            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5562            if (utf8) BACKCHAR(eptr);            if (utf) BACKCHAR(eptr);
5563            }            }
5564          }          }
5565    
# Line 5250  for (;;) Line 5570  for (;;)
5570          {          {
5571          for (i = min; i < max; i++)          for (i = min; i < max; i++)
5572            {            {
           int len = 1;  
5573            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
5574              {              {
5575              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5576              break;              break;
5577              }              }
5578            if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }            else
           if (UCD_CATEGORY(c) == ucp_M) break;  
           eptr += len;  
           while (eptr < md->end_subject)  
5579              {              {
5580              len = 1;              int lgb, rgb;
5581              if (!utf8) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
5582              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
5583              eptr += len;              while (eptr < md->end_subject)
5584                  {
5585                  int len = 1;
5586                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5587                  rgb = UCD_GRAPHBREAK(c);
5588                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5589                  lgb = rgb;
5590                  eptr += len;
5591                  }
5592              }              }
5593              CHECK_PARTIAL();
5594            }            }
5595    
5596          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5279  for (;;) Line 5604  for (;;)
5604            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5605            for (;;)                        /* Move back over one extended */            for (;;)                        /* Move back over one extended */
5606              {              {
5607              if (!utf8) c = *eptr; else              if (!utf) c = *eptr; else
5608                {                {
5609                BACKCHAR(eptr);                BACKCHAR(eptr);
5610                GETCHAR(c, eptr);                GETCHAR(c, eptr);
# Line 5293  for (;;) Line 5618  for (;;)
5618        else        else
5619  #endif   /* SUPPORT_UCP */  #endif   /* SUPPORT_UCP */
5620    
5621  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF
5622        /* UTF-8 mode */        if (utf)
   
       if (utf8)  
5623          {          {
5624          switch(ctype)          switch(ctype)
5625            {            {
# Line 5311  for (;;) Line 5634  for (;;)
5634                  break;                  break;
5635                  }                  }
5636                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
5637                  if (md->partial != 0 &&    /* Take care with CRLF partial */
5638                      eptr + 1 >= md->end_subject &&
5639                      NLBLOCK->nltype == NLTYPE_FIXED &&
5640                      NLBLOCK->nllen == 2 &&
5641                      RAWUCHAR(eptr) == NLBLOCK->nl[0])
5642                    {
5643                    md->hitend = TRUE;
5644                    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5645                    }
5646                eptr++;                eptr++;
5647                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5648                }                }
5649              }              }
5650    
# Line 5328  for (;;) Line 5660  for (;;)
5660                  break;                  break;
5661                  }                  }
5662                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
5663                  if (md->partial != 0 &&    /* Take care with CRLF partial */
5664                      eptr + 1 >= md->end_subject &&
5665                      NLBLOCK->nltype == NLTYPE_FIXED &&
5666                      NLBLOCK->nllen == 2 &&
5667                      RAWUCHAR(eptr) == NLBLOCK->nl[0])
5668                    {
5669                    md->hitend = TRUE;
5670                    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5671                    }
5672                eptr++;                eptr++;
5673                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5674                }                }
5675              }              }
5676            break;            break;
# Line 5345  for (;;) Line 5686  for (;;)
5686                  break;                  break;
5687                  }                  }
5688                eptr++;                eptr++;
5689                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5690                }                }
5691              }              }
5692            else            else
# Line 5377  for (;;) Line 5718  for (;;)
5718                break;                break;
5719                }                }
5720              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5721              if (c == 0x000d)              if (c == CHAR_CR)
5722                {                {
5723                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5724                if (*eptr == 0x000a) eptr++;                if (RAWUCHAR(eptr) == CHAR_LF) eptr++;
5725                }                }
5726              else              else
5727                {                {
5728                if (c != 0x000a &&                if (c != CHAR_LF &&
5729                    (md->bsr_anycrlf ||                    (md->bsr_anycrlf ||
5730                     (c != 0x000b && c != 0x000c &&                     (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5731                      c != 0x0085 && c != 0x2028 && c != 0x2029)))  #ifndef EBCDIC
5732                        && c != 0x2028 && c != 0x2029
5733    #endif  /* Not EBCDIC */
5734                        )))
5735                  break;                  break;
5736                eptr += len;                eptr += len;
5737                }                }
# Line 5408  for (;;) Line 5752  for (;;)
5752              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5753