/[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 976 by ph10, Sat Jun 16 17:53:17 2012 UTC revision 1238 by ph10, Sat Jan 5 16:27:59 2013 UTC
# Line 92  because the offset vector is always a mu Line 92  because the offset vector is always a mu
92  static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };  static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
93  static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };  static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };
94    
   
   
95  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
96  /*************************************************  /*************************************************
97  *        Debugging function to print chars       *  *        Debugging function to print chars       *
# Line 114  Returns:     nothing Line 112  Returns:     nothing
112  static void  static void
113  pchars(const pcre_uchar *p, int length, BOOL is_subject, match_data *md)  pchars(const pcre_uchar *p, int length, BOOL is_subject, match_data *md)
114  {  {
115  unsigned int c;  pcre_uint32 c;
116    BOOL utf = md->utf;
117  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;
118  while (length-- > 0)  while (length-- > 0)
119    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);
120  }  }
121  #endif  #endif
122    
# Line 150  match_ref(int offset, register PCRE_PUCH Line 149  match_ref(int offset, register PCRE_PUCH
149  {  {
150  PCRE_PUCHAR eptr_start = eptr;  PCRE_PUCHAR eptr_start = eptr;
151  register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];  register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];
152    #ifdef SUPPORT_UTF
153    BOOL utf = md->utf;
154    #endif
155    
156  #ifdef PCRE_DEBUG  #ifdef PCRE_DEBUG
157  if (eptr >= md->end_subject)  if (eptr >= md->end_subject)
# Line 177  if (caseless) Line 179  if (caseless)
179    {    {
180  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
181  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
182    if (md->utf)    if (utf)
183      {      {
184      /* 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
185      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
186      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.
187      (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
188      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
189      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
190      reference, not along the subject (earlier code did this wrong). */      length along the reference, not along the subject (earlier code did this
191        wrong). */
192    
193      PCRE_PUCHAR endptr = p + length;      PCRE_PUCHAR endptr = p + length;
194      while (p < endptr)      while (p < endptr)
195        {        {
196        int c, d;        pcre_uint32 c, d;
197          const ucd_record *ur;
198        if (eptr >= md->end_subject) return -2;   /* Partial match */        if (eptr >= md->end_subject) return -2;   /* Partial match */
199        GETCHARINC(c, eptr);        GETCHARINC(c, eptr);
200        GETCHARINC(d, p);        GETCHARINC(d, p);
201        if (c != d && c != UCD_OTHERCASE(d)) return -1;        ur = GET_UCD(d);
202          if (c != d && c != d + ur->other_case)
203            {
204            const pcre_uint32 *pp = PRIV(ucd_caseless_sets) + ur->caseset;
205            for (;;)
206              {
207              if (c < *pp) return -1;
208              if (c == *pp++) break;
209              }
210            }
211        }        }
212      }      }
213    else    else
# Line 206  if (caseless) Line 219  if (caseless)
219      {      {
220      while (length-- > 0)      while (length-- > 0)
221        {        {
222          pcre_uchar cc, cp;
223        if (eptr >= md->end_subject) return -2;   /* Partial match */        if (eptr >= md->end_subject) return -2;   /* Partial match */
224        if (TABLE_GET(*p, md->lcc, *p) != TABLE_GET(*eptr, md->lcc, *eptr)) return -1;        cc = RAWUCHARTEST(eptr);
225          cp = RAWUCHARTEST(p);
226          if (TABLE_GET(cp, md->lcc, cp) != TABLE_GET(cc, md->lcc, cc)) return -1;
227        p++;        p++;
228        eptr++;        eptr++;
229        }        }
# Line 222  else Line 238  else
238    while (length-- > 0)    while (length-- > 0)
239      {      {
240      if (eptr >= md->end_subject) return -2;   /* Partial match */      if (eptr >= md->end_subject) return -2;   /* Partial match */
241      if (*p++ != *eptr++) return -1;      if (RAWUCHARINCTEST(p) != RAWUCHARINCTEST(eptr)) return -1;
242      }      }
243    }    }
244    
# Line 278  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM Line 294  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM
294         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
295         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
296         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,         RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
297         RM61,  RM62, RM63, RM64, RM65, RM66 };         RM61,  RM62, RM63, RM64, RM65, RM66, RM67 };
298    
299  /* 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
300  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 296  actually used in this definition. */ Line 312  actually used in this definition. */
312    }    }
313  #define RRETURN(ra) \  #define RRETURN(ra) \
314    { \    { \
315    printf("match() returned %d from line %d ", ra, __LINE__); \    printf("match() returned %d from line %d\n", ra, __LINE__); \
316    return ra; \    return ra; \
317    }    }
318  #else  #else
# Line 387  typedef struct heapframe { Line 403  typedef struct heapframe {
403    
404  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
405    int Xprop_type;    int Xprop_type;
406    int Xprop_value;    unsigned int Xprop_value;
407    int Xprop_fail_result;    int Xprop_fail_result;
408    int Xoclength;    int Xoclength;
409    pcre_uchar Xocchars[6];    pcre_uchar Xocchars[6];
# Line 400  typedef struct heapframe { Line 416  typedef struct heapframe {
416    int Xlength;    int Xlength;
417    int Xmax;    int Xmax;
418    int Xmin;    int Xmin;
419    int Xnumber;    unsigned int Xnumber;
420    int Xoffset;    int Xoffset;
421    int Xop;    unsigned int Xop;
422    int Xsave_capture_last;    int Xsave_capture_last;
423    int Xsave_offset1, Xsave_offset2, Xsave_offset3;    int Xsave_offset1, Xsave_offset2, Xsave_offset3;
424    int Xstacksave[REC_STACK_SAVE_MAX];    int Xstacksave[REC_STACK_SAVE_MAX];
# Line 488  so they can be ordinary variables in all Line 504  so they can be ordinary variables in all
504    
505  register int  rrc;         /* Returns from recursive calls */  register int  rrc;         /* Returns from recursive calls */
506  register int  i;           /* Used for loops not involving calls to RMATCH() */  register int  i;           /* Used for loops not involving calls to RMATCH() */
507  register unsigned int c;   /* Character values not kept over RMATCH() calls */  register pcre_uint32 c;    /* Character values not kept over RMATCH() calls */
508  register BOOL utf;         /* Local copy of UTF flag for speed */  register BOOL utf;         /* Local copy of UTF flag for speed */
509    
510  BOOL minimize, possessive; /* Quantifier options */  BOOL minimize, possessive; /* Quantifier options */
# Line 605  BOOL prev_is_word; Line 621  BOOL prev_is_word;
621    
622  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
623  int prop_type;  int prop_type;
624  int prop_value;  unsigned int prop_value;
625  int prop_fail_result;  int prop_fail_result;
626  int oclength;  int oclength;
627  pcre_uchar occhars[6];  pcre_uchar occhars[6];
# Line 616  int ctype; Line 632  int ctype;
632  int length;  int length;
633  int max;  int max;
634  int min;  int min;
635  int number;  unsigned int number;
636  int offset;  int offset;
637  int op;  unsigned int op;
638  int save_capture_last;  int save_capture_last;
639  int save_offset1, save_offset2, save_offset3;  int save_offset1, save_offset2, save_offset3;
640  int stacksave[REC_STACK_SAVE_MAX];  int stacksave[REC_STACK_SAVE_MAX];
# Line 737  for (;;) Line 753  for (;;)
753      unaltered. */      unaltered. */
754    
755      else if (rrc == MATCH_SKIP_ARG &&      else if (rrc == MATCH_SKIP_ARG &&
756          STRCMP_UC_UC(ecode + 2, md->start_match_ptr) == 0)          STRCMP_UC_UC_TEST(ecode + 2, md->start_match_ptr) == 0)
757        {        {
758        md->start_match_ptr = eptr;        md->start_match_ptr = eptr;
759        RRETURN(MATCH_SKIP);        RRETURN(MATCH_SKIP);
# Line 1262  for (;;) Line 1278  for (;;)
1278          cb.version          = 2;   /* Version 1 of the callout block */          cb.version          = 2;   /* Version 1 of the callout block */
1279          cb.callout_number   = ecode[LINK_SIZE+2];          cb.callout_number   = ecode[LINK_SIZE+2];
1280          cb.offset_vector    = md->offset_vector;          cb.offset_vector    = md->offset_vector;
1281  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
1282          cb.subject          = (PCRE_SPTR)md->start_subject;          cb.subject          = (PCRE_SPTR)md->start_subject;
1283  #else  #elif defined COMPILE_PCRE16
1284          cb.subject          = (PCRE_SPTR16)md->start_subject;          cb.subject          = (PCRE_SPTR16)md->start_subject;
1285    #elif defined COMPILE_PCRE32
1286            cb.subject          = (PCRE_SPTR32)md->start_subject;
1287  #endif  #endif
1288          cb.subject_length   = (int)(md->end_subject - md->start_subject);          cb.subject_length   = (int)(md->end_subject - md->start_subject);
1289          cb.start_match      = (int)(mstart - md->start_subject);          cb.start_match      = (int)(mstart - md->start_subject);
# Line 1295  for (;;) Line 1313  for (;;)
1313          }          }
1314        else        else
1315          {          {
1316          int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/          unsigned int recno = GET2(ecode, LINK_SIZE + 2);   /* Recursion group number*/
1317          condition = (recno == RREF_ANY || recno == md->recursive->group_num);          condition = (recno == RREF_ANY || recno == md->recursive->group_num);
1318    
1319          /* 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 1367  for (;;) Line 1385  for (;;)
1385    
1386        if (!condition && condcode == OP_NCREF)        if (!condition && condcode == OP_NCREF)
1387          {          {
1388          int refno = offset >> 1;          unsigned int refno = offset >> 1;
1389          pcre_uchar *slotA = md->name_table;          pcre_uchar *slotA = md->name_table;
1390    
1391          for (i = 0; i < md->name_count; i++)          for (i = 0; i < md->name_count; i++)
# Line 1685  for (;;) Line 1703  for (;;)
1703        cb.version          = 2;   /* Version 1 of the callout block */        cb.version          = 2;   /* Version 1 of the callout block */
1704        cb.callout_number   = ecode[1];        cb.callout_number   = ecode[1];
1705        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
1706  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
1707        cb.subject          = (PCRE_SPTR)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
1708  #else  #elif defined COMPILE_PCRE16
1709        cb.subject          = (PCRE_SPTR16)md->start_subject;        cb.subject          = (PCRE_SPTR16)md->start_subject;
1710    #elif defined COMPILE_PCRE32
1711          cb.subject          = (PCRE_SPTR32)md->start_subject;
1712  #endif  #endif
1713        cb.subject_length   = (int)(md->end_subject - md->start_subject);        cb.subject_length   = (int)(md->end_subject - md->start_subject);
1714        cb.start_match      = (int)(mstart - md->start_subject);        cb.start_match      = (int)(mstart - md->start_subject);
# Line 1725  for (;;) Line 1745  for (;;)
1745      case OP_RECURSE:      case OP_RECURSE:
1746        {        {
1747        recursion_info *ri;        recursion_info *ri;
1748        int recno;        unsigned int recno;
1749    
1750        callpat = md->start_code + GET(ecode, 1);        callpat = md->start_code + GET(ecode, 1);
1751        recno = (callpat == md->start_code)? 0 :        recno = (callpat == md->start_code)? 0 :
# Line 2079  for (;;) Line 2099  for (;;)
2099              eptr + 1 >= md->end_subject &&              eptr + 1 >= md->end_subject &&
2100              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
2101              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
2102              *eptr == NLBLOCK->nl[0])              RAWUCHARTEST(eptr) == NLBLOCK->nl[0])
2103            {            {
2104            md->hitend = TRUE;            md->hitend = TRUE;
2105            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 2123  for (;;) Line 2143  for (;;)
2143            eptr + 1 >= md->end_subject &&            eptr + 1 >= md->end_subject &&
2144            NLBLOCK->nltype == NLTYPE_FIXED &&            NLBLOCK->nltype == NLTYPE_FIXED &&
2145            NLBLOCK->nllen == 2 &&            NLBLOCK->nllen == 2 &&
2146            *eptr == NLBLOCK->nl[0])            RAWUCHARTEST(eptr) == NLBLOCK->nl[0])
2147          {          {
2148          md->hitend = TRUE;          md->hitend = TRUE;
2149          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 2266  for (;;) Line 2286  for (;;)
2286          eptr + 1 >= md->end_subject &&          eptr + 1 >= md->end_subject &&
2287          NLBLOCK->nltype == NLTYPE_FIXED &&          NLBLOCK->nltype == NLTYPE_FIXED &&
2288          NLBLOCK->nllen == 2 &&          NLBLOCK->nllen == 2 &&
2289          *eptr == NLBLOCK->nl[0])          RAWUCHARTEST(eptr) == NLBLOCK->nl[0])
2290        {        {
2291        md->hitend = TRUE;        md->hitend = TRUE;
2292        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 2415  for (;;) Line 2435  for (;;)
2435        {        {
2436        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2437    
2438        case 0x000d:        case CHAR_CR:
2439        if (eptr >= md->end_subject)        if (eptr >= md->end_subject)
2440          {          {
2441          SCHECK_PARTIAL();          SCHECK_PARTIAL();
2442          }          }
2443        else if (*eptr == 0x0a) eptr++;        else if (RAWUCHARTEST(eptr) == CHAR_LF) eptr++;
2444        break;        break;
2445    
2446        case 0x000a:        case CHAR_LF:
2447        break;        break;
2448    
2449        case 0x000b:        case CHAR_VT:
2450        case 0x000c:        case CHAR_FF:
2451        case 0x0085:        case CHAR_NEL:
2452    #ifndef EBCDIC
2453        case 0x2028:        case 0x2028:
2454        case 0x2029:        case 0x2029:
2455    #endif  /* Not EBCDIC */
2456        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2457        break;        break;
2458        }        }
# Line 2446  for (;;) Line 2468  for (;;)
2468      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2469      switch(c)      switch(c)
2470        {        {
2471          HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
2472        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);  
2473        }        }
2474      ecode++;      ecode++;
2475      break;      break;
# Line 2480  for (;;) Line 2483  for (;;)
2483      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2484      switch(c)      switch(c)
2485        {        {
2486          HSPACE_CASES: break;  /* Byte and multibyte cases */
2487        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;  
2488        }        }
2489      ecode++;      ecode++;
2490      break;      break;
# Line 2514  for (;;) Line 2498  for (;;)
2498      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2499      switch(c)      switch(c)
2500        {        {
2501          VSPACE_CASES: RRETURN(MATCH_NOMATCH);
2502        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);  
2503        }        }
2504      ecode++;      ecode++;
2505      break;      break;
# Line 2536  for (;;) Line 2513  for (;;)
2513      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2514      switch(c)      switch(c)
2515        {        {
2516          VSPACE_CASES: break;
2517        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;  
2518        }        }
2519      ecode++;      ecode++;
2520      break;      break;
# Line 2562  for (;;) Line 2532  for (;;)
2532        }        }
2533      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2534        {        {
2535          const pcre_uint32 *cp;
2536        const ucd_record *prop = GET_UCD(c);        const ucd_record *prop = GET_UCD(c);
2537    
2538        switch(ecode[1])        switch(ecode[1])
# Line 2622  for (;;) Line 2593  for (;;)
2593            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2594          break;          break;
2595    
2596            case PT_CLIST:
2597            cp = PRIV(ucd_caseless_sets) + ecode[2];
2598            for (;;)
2599              {
2600              if (c < *cp)
2601                { if (op == OP_PROP) { RRETURN(MATCH_NOMATCH); } else break; }
2602              if (c == *cp++)
2603                { if (op == OP_PROP) break; else { RRETURN(MATCH_NOMATCH); } }
2604              }
2605            break;
2606    
2607          /* This should never occur */          /* This should never occur */
2608    
2609          default:          default:
# Line 2641  for (;;) Line 2623  for (;;)
2623        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2624        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2625        }        }
2626      GETCHARINCTEST(c, eptr);      else
     if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
     while (eptr < md->end_subject)  
2627        {        {
2628        int len = 1;        int lgb, rgb;
2629        if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }        GETCHARINCTEST(c, eptr);
2630        if (UCD_CATEGORY(c) != ucp_M) break;        lgb = UCD_GRAPHBREAK(c);
2631        eptr += len;        while (eptr < md->end_subject)
2632            {
2633            int len = 1;
2634            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2635            rgb = UCD_GRAPHBREAK(c);
2636            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2637            lgb = rgb;
2638            eptr += len;
2639            }
2640        }        }
2641      CHECK_PARTIAL();      CHECK_PARTIAL();
2642      ecode++;      ecode++;
2643      break;      break;
2644  #endif  #endif  /* SUPPORT_UCP */
2645    
2646    
2647      /* 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 3162  for (;;) Line 3150  for (;;)
3150          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */          CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
3151          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
3152          }          }
3153        while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);        while (length-- > 0) if (*ecode++ != RAWUCHARINC(eptr)) RRETURN(MATCH_NOMATCH);
3154        }        }
3155      else      else
3156  #endif  #endif
# Line 3202  for (;;) Line 3190  for (;;)
3190    
3191        if (fc < 128)        if (fc < 128)
3192          {          {
3193          if (md->lcc[fc]          pcre_uchar cc = RAWUCHAR(eptr);
3194              != TABLE_GET(*eptr, md->lcc, *eptr)) RRETURN(MATCH_NOMATCH);          if (md->lcc[fc] != TABLE_GET(cc, md->lcc, cc)) RRETURN(MATCH_NOMATCH);
3195          ecode++;          ecode++;
3196          eptr++;          eptr++;
3197          }          }
# Line 3214  for (;;) Line 3202  for (;;)
3202    
3203        else        else
3204          {          {
3205          unsigned int dc;          pcre_uint32 dc;
3206          GETCHARINC(dc, eptr);          GETCHARINC(dc, eptr);
3207          ecode += length;          ecode += length;
3208    
# Line 3324  for (;;) Line 3312  for (;;)
3312        if (length > 1)        if (length > 1)
3313          {          {
3314  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3315          unsigned int othercase;          pcre_uint32 othercase;
3316          if (op >= OP_STARI &&     /* Caseless */          if (op >= OP_STARI &&     /* Caseless */
3317              (othercase = UCD_OTHERCASE(fc)) != fc)              (othercase = UCD_OTHERCASE(fc)) != fc)
3318            oclength = PRIV(ord2utf)(othercase, occhars);            oclength = PRIV(ord2utf)(othercase, occhars);
# Line 3451  for (;;) Line 3439  for (;;)
3439    
3440        for (i = 1; i <= min; i++)        for (i = 1; i <= min; i++)
3441          {          {
3442            pcre_uint32 cc;                 /* Faster than pcre_uchar */
3443          if (eptr >= md->end_subject)          if (eptr >= md->end_subject)
3444            {            {
3445            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3446            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3447            }            }
3448          if (fc != *eptr && foc != *eptr) RRETURN(MATCH_NOMATCH);          cc = RAWUCHARTEST(eptr);
3449            if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
3450          eptr++;          eptr++;
3451          }          }
3452        if (min == max) continue;        if (min == max) continue;
# Line 3464  for (;;) Line 3454  for (;;)
3454          {          {
3455          for (fi = min;; fi++)          for (fi = min;; fi++)
3456            {            {
3457              pcre_uint32 cc;               /* Faster than pcre_uchar */
3458            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
3459            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3460            if (fi >= max) RRETURN(MATCH_NOMATCH);            if (fi >= max) RRETURN(MATCH_NOMATCH);
# Line 3472  for (;;) Line 3463  for (;;)
3463              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3464              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3465              }              }
3466            if (fc != *eptr && foc != *eptr) RRETURN(MATCH_NOMATCH);            cc = RAWUCHARTEST(eptr);
3467              if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
3468            eptr++;            eptr++;
3469            }            }
3470          /* Control never gets here */          /* Control never gets here */
# Line 3482  for (;;) Line 3474  for (;;)
3474          pp = eptr;          pp = eptr;
3475          for (i = min; i < max; i++)          for (i = min; i < max; i++)
3476            {            {
3477              pcre_uint32 cc;               /* Faster than pcre_uchar */
3478            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
3479              {              {
3480              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3481              break;              break;
3482              }              }
3483            if (fc != *eptr && foc != *eptr) break;            cc = RAWUCHARTEST(eptr);
3484              if (fc != cc && foc != cc) break;
3485            eptr++;            eptr++;
3486            }            }
3487    
# Line 3515  for (;;) Line 3509  for (;;)
3509            SCHECK_PARTIAL();            SCHECK_PARTIAL();
3510            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
3511            }            }
3512          if (fc != *eptr++) RRETURN(MATCH_NOMATCH);          if (fc != RAWUCHARINCTEST(eptr)) RRETURN(MATCH_NOMATCH);
3513          }          }
3514    
3515        if (min == max) continue;        if (min == max) continue;
# Line 3532  for (;;) Line 3526  for (;;)
3526              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3527              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3528              }              }
3529            if (fc != *eptr++) RRETURN(MATCH_NOMATCH);            if (fc != RAWUCHARINCTEST(eptr)) RRETURN(MATCH_NOMATCH);
3530            }            }
3531          /* Control never gets here */          /* Control never gets here */
3532          }          }
# Line 3546  for (;;) Line 3540  for (;;)
3540              SCHECK_PARTIAL();              SCHECK_PARTIAL();
3541              break;              break;
3542              }              }
3543            if (fc != *eptr) break;            if (fc != RAWUCHARTEST(eptr)) break;
3544            eptr++;            eptr++;
3545            }            }
3546          if (possessive) continue;          if (possessive) continue;
# Line 3575  for (;;) Line 3569  for (;;)
3569  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3570      if (utf)      if (utf)
3571        {        {
3572        register unsigned int ch, och;        register pcre_uint32 ch, och;
3573    
3574        ecode++;        ecode++;
3575        GETCHARINC(ch, ecode);        GETCHARINC(ch, ecode);
# Line 3602  for (;;) Line 3596  for (;;)
3596      else      else
3597  #endif  #endif
3598        {        {
3599        register unsigned int ch = ecode[1];        register pcre_uint32 ch = ecode[1];
3600        c = *eptr++;        c = *eptr++;
3601        if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))        if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3602          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
# Line 3716  for (;;) Line 3710  for (;;)
3710  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3711        if (utf)        if (utf)
3712          {          {
3713          register unsigned int d;          register pcre_uint32 d;
3714          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3715            {            {
3716            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
# Line 3751  for (;;) Line 3745  for (;;)
3745  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3746          if (utf)          if (utf)
3747            {            {
3748            register unsigned int d;            register pcre_uint32 d;
3749            for (fi = min;; fi++)            for (fi = min;; fi++)
3750              {              {
3751              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
# Line 3796  for (;;) Line 3790  for (;;)
3790  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3791          if (utf)          if (utf)
3792            {            {
3793            register unsigned int d;            register pcre_uint32 d;
3794            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3795              {              {
3796              int len = 1;              int len = 1;
# Line 3853  for (;;) Line 3847  for (;;)
3847  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3848        if (utf)        if (utf)
3849          {          {
3850          register unsigned int d;          register pcre_uint32 d;
3851          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3852            {            {
3853            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
# Line 3887  for (;;) Line 3881  for (;;)
3881  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3882          if (utf)          if (utf)
3883            {            {
3884            register unsigned int d;            register pcre_uint32 d;
3885            for (fi = min;; fi++)            for (fi = min;; fi++)
3886              {              {
3887              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
# Line 3931  for (;;) Line 3925  for (;;)
3925  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3926          if (utf)          if (utf)
3927            {            {
3928            register unsigned int d;            register pcre_uint32 d;
3929            for (i = min; i < max; i++)            for (i = min; i < max; i++)
3930              {              {
3931              int len = 1;              int len = 1;
# Line 4207  for (;;) Line 4201  for (;;)
4201              }              }
4202            break;            break;
4203    
4204              case PT_CLIST:
4205              for (i = 1; i <= min; i++)
4206                {
4207                const pcre_uint32 *cp;
4208                if (eptr >= md->end_subject)
4209                  {
4210                  SCHECK_PARTIAL();
4211                  RRETURN(MATCH_NOMATCH);
4212                  }
4213                GETCHARINCTEST(c, eptr);
4214                cp = PRIV(ucd_caseless_sets) + prop_value;
4215                for (;;)
4216                  {
4217                  if (c < *cp)
4218                    { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4219                  if (c == *cp++)
4220                    { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4221                  }
4222                }
4223              break;
4224    
4225            /* This should not occur */            /* This should not occur */
4226    
4227            default:            default:
# Line 4226  for (;;) Line 4241  for (;;)
4241              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4242              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4243              }              }
4244            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4245              {              {
4246              int len = 1;              int lgb, rgb;
4247              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4248              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4249              eptr += len;             while (eptr < md->end_subject)
4250                  {
4251                  int len = 1;
4252                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4253                  rgb = UCD_GRAPHBREAK(c);
4254                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4255                  lgb = rgb;
4256                  eptr += len;
4257                  }
4258              }              }
4259            CHECK_PARTIAL();            CHECK_PARTIAL();
4260            }            }
# Line 4260  for (;;) Line 4281  for (;;)
4281                eptr + 1 >= md->end_subject &&                eptr + 1 >= md->end_subject &&
4282                NLBLOCK->nltype == NLTYPE_FIXED &&                NLBLOCK->nltype == NLTYPE_FIXED &&
4283                NLBLOCK->nllen == 2 &&                NLBLOCK->nllen == 2 &&
4284                *eptr == NLBLOCK->nl[0])                RAWUCHAR(eptr) == NLBLOCK->nl[0])
4285              {              {
4286              md->hitend = TRUE;              md->hitend = TRUE;
4287              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 4301  for (;;) Line 4322  for (;;)
4322              {              {
4323              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4324    
4325              case 0x000d:              case CHAR_CR:
4326              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && RAWUCHAR(eptr) == CHAR_LF) eptr++;
4327              break;              break;
4328    
4329              case 0x000a:              case CHAR_LF:
4330              break;              break;
4331    
4332              case 0x000b:              case CHAR_VT:
4333              case 0x000c:              case CHAR_FF:
4334              case 0x0085:              case CHAR_NEL:
4335    #ifndef EBCDIC
4336              case 0x2028:              case 0x2028:
4337              case 0x2029:              case 0x2029:
4338    #endif  /* Not EBCDIC */
4339              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4340              break;              break;
4341              }              }
# Line 4330  for (;;) Line 4353  for (;;)
4353            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4354            switch(c)            switch(c)
4355              {              {
4356                HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
4357              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);  
4358              }              }
4359            }            }
4360          break;          break;
# Line 4366  for (;;) Line 4370  for (;;)
4370            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4371            switch(c)            switch(c)
4372              {              {
4373                HSPACE_CASES: break;  /* Byte and multibyte cases */
4374              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;  
4375              }              }
4376            }            }
4377          break;          break;
# Line 4402  for (;;) Line 4387  for (;;)
4387            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4388            switch(c)            switch(c)
4389              {              {
4390                VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4391              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);  
4392              }              }
4393            }            }
4394          break;          break;
# Line 4426  for (;;) Line 4404  for (;;)
4404            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4405            switch(c)            switch(c)
4406              {              {
4407                VSPACE_CASES: break;
4408              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;  
4409              }              }
4410            }            }
4411          break;          break;
# Line 4456  for (;;) Line 4427  for (;;)
4427          case OP_DIGIT:          case OP_DIGIT:
4428          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4429            {            {
4430              pcre_uchar cc;
4431    
4432            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4433              {              {
4434              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4435              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4436              }              }
4437            if (*eptr >= 128 || (md->ctypes[*eptr] & ctype_digit) == 0)            cc = RAWUCHAR(eptr);
4438              if (cc >= 128 || (md->ctypes[cc] & ctype_digit) == 0)
4439              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4440            eptr++;            eptr++;
4441            /* 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 */
# Line 4471  for (;;) Line 4445  for (;;)
4445          case OP_NOT_WHITESPACE:          case OP_NOT_WHITESPACE:
4446          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4447            {            {
4448              pcre_uchar cc;
4449    
4450            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4451              {              {
4452              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4453              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4454              }              }
4455            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0)            cc = RAWUCHAR(eptr);
4456              if (cc < 128 && (md->ctypes[cc] & ctype_space) != 0)
4457              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4458            eptr++;            eptr++;
4459            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
# Line 4486  for (;;) Line 4463  for (;;)
4463          case OP_WHITESPACE:          case OP_WHITESPACE:
4464          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4465            {            {
4466              pcre_uchar cc;
4467    
4468            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4469              {              {
4470              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4471              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4472              }              }
4473            if (*eptr >= 128 || (md->ctypes[*eptr] & ctype_space) == 0)            cc = RAWUCHAR(eptr);
4474              if (cc >= 128 || (md->ctypes[cc] & ctype_space) == 0)
4475              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4476            eptr++;            eptr++;
4477            /* 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 */
# Line 4501  for (;;) Line 4481  for (;;)
4481          case OP_NOT_WORDCHAR:          case OP_NOT_WORDCHAR:
4482          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4483            {            {
4484              pcre_uchar cc;
4485    
4486            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4487              {              {
4488              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4489              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4490              }              }
4491            if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)            cc = RAWUCHAR(eptr);
4492              if (cc < 128 && (md->ctypes[cc] & ctype_word) != 0)
4493              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4494            eptr++;            eptr++;
4495            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
# Line 4516  for (;;) Line 4499  for (;;)
4499          case OP_WORDCHAR:          case OP_WORDCHAR:
4500          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
4501            {            {
4502              pcre_uchar cc;
4503    
4504            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
4505              {              {
4506              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4507              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4508              }              }
4509            if (*eptr >= 128 || (md->ctypes[*eptr] & ctype_word) == 0)            cc = RAWUCHAR(eptr);
4510              if (cc >= 128 || (md->ctypes[cc] & ctype_word) == 0)
4511              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4512            eptr++;            eptr++;
4513            /* 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 */
# Line 4592  for (;;) Line 4578  for (;;)
4578              {              {
4579              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4580    
4581              case 0x000d:              case CHAR_CR:
4582              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4583              break;              break;
4584    
4585              case 0x000a:              case CHAR_LF:
4586              break;              break;
4587    
4588              case 0x000b:              case CHAR_VT:
4589              case 0x000c:              case CHAR_FF:
4590              case 0x0085:              case CHAR_NEL:
4591  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4592              case 0x2028:              case 0x2028:
4593              case 0x2029:              case 0x2029:
4594  #endif  #endif
# Line 4623  for (;;) Line 4609  for (;;)
4609            switch(*eptr++)            switch(*eptr++)
4610              {              {
4611              default: break;              default: break;
4612              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
4613              case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4614              case 0xa0:      /* NBSP */              HSPACE_MULTIBYTE_CASES:
 #ifdef COMPILE_PCRE16  
             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 */  
4615  #endif  #endif
4616              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4617              }              }
# Line 4660  for (;;) Line 4629  for (;;)
4629            switch(*eptr++)            switch(*eptr++)
4630              {              {
4631              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4632              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
4633              case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4634              case 0xa0:      /* NBSP */              HSPACE_MULTIBYTE_CASES:
 #ifdef COMPILE_PCRE16  
             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 */  
4635  #endif  #endif
4636              break;              break;
4637              }              }
# Line 4696  for (;;) Line 4648  for (;;)
4648              }              }
4649            switch(*eptr++)            switch(*eptr++)
4650              {              {
4651              default: break;              VSPACE_BYTE_CASES:
4652              case 0x0a:      /* LF */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4653              case 0x0b:      /* VT */              VSPACE_MULTIBYTE_CASES:
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
 #ifdef COMPILE_PCRE16  
             case 0x2028:    /* LINE SEPARATOR */  
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4654  #endif  #endif
4655              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4656                default: break;
4657              }              }
4658            }            }
4659          break;          break;
# Line 4722  for (;;) Line 4669  for (;;)
4669            switch(*eptr++)            switch(*eptr++)
4670              {              {
4671              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4672              case 0x0a:      /* LF */              VSPACE_BYTE_CASES:
4673              case 0x0b:      /* VT */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4674              case 0x0c:      /* FF */              VSPACE_MULTIBYTE_CASES:
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
 #ifdef COMPILE_PCRE16  
             case 0x2028:    /* LINE SEPARATOR */  
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4675  #endif  #endif
4676              break;              break;
4677              }              }
# Line 5007  for (;;) Line 4949  for (;;)
4949              }              }
4950            /* Control never gets here */            /* Control never gets here */
4951    
4952            /* This should never occur */            case PT_CLIST:
4953              for (fi = min;; fi++)
4954                {
4955                const pcre_uint32 *cp;
4956                RMATCH(eptr, ecode, offset_top, md, eptrb, RM67);
4957                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4958                if (fi >= max) RRETURN(MATCH_NOMATCH);
4959                if (eptr >= md->end_subject)
4960                  {
4961                  SCHECK_PARTIAL();
4962                  RRETURN(MATCH_NOMATCH);
4963                  }
4964                GETCHARINCTEST(c, eptr);
4965                cp = PRIV(ucd_caseless_sets) + prop_value;
4966                for (;;)
4967                  {
4968                  if (c < *cp)
4969                    { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4970                  if (c == *cp++)
4971                    { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4972                  }
4973                }
4974              /* Control never gets here */
4975    
4976              /* This should never occur */
4977            default:            default:
4978            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4979            }            }
# Line 5029  for (;;) Line 4994  for (;;)
4994              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4995              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4996              }              }
4997            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4998              {              {
4999              int len = 1;              int lgb, rgb;
5000              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
5001              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
5002              eptr += len;              while (eptr < md->end_subject)
5003                  {
5004                  int len = 1;
5005                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5006                  rgb = UCD_GRAPHBREAK(c);
5007                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5008                  lgb = rgb;
5009                  eptr += len;
5010                  }
5011              }              }
5012            CHECK_PARTIAL();            CHECK_PARTIAL();
5013            }            }
# Line 5082  for (;;) Line 5053  for (;;)
5053              switch(c)              switch(c)
5054                {                {
5055                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5056                case 0x000d:                case CHAR_CR:
5057                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && RAWUCHAR(eptr) == CHAR_LF) eptr++;
5058                break;                break;
5059                case 0x000a:  
5060                  case CHAR_LF:
5061                break;                break;
5062    
5063                case 0x000b:                case CHAR_VT:
5064                case 0x000c:                case CHAR_FF:
5065                case 0x0085:                case CHAR_NEL:
5066    #ifndef EBCDIC
5067                case 0x2028:                case 0x2028:
5068                case 0x2029:                case 0x2029:
5069    #endif  /* Not EBCDIC */
5070                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5071                break;                break;
5072                }                }
# Line 5101  for (;;) Line 5075  for (;;)
5075              case OP_NOT_HSPACE:              case OP_NOT_HSPACE:
5076              switch(c)              switch(c)
5077                {                {
5078                  HSPACE_CASES: RRETURN(MATCH_NOMATCH);
5079                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);  
5080                }                }
5081              break;              break;
5082    
5083              case OP_HSPACE:              case OP_HSPACE:
5084              switch(c)              switch(c)
5085                {                {
5086                  HSPACE_CASES: break;
5087                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;  
5088                }                }
5089              break;              break;
5090    
5091              case OP_NOT_VSPACE:              case OP_NOT_VSPACE:
5092              switch(c)              switch(c)
5093                {                {
5094                  VSPACE_CASES: RRETURN(MATCH_NOMATCH);
5095                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);  
5096                }                }
5097              break;              break;
5098    
5099              case OP_VSPACE:              case OP_VSPACE:
5100              switch(c)              switch(c)
5101                {                {
5102                  VSPACE_CASES: break;
5103                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;  
5104                }                }
5105              break;              break;
5106    
# Line 5256  for (;;) Line 5178  for (;;)
5178              switch(c)              switch(c)
5179                {                {
5180                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5181                case 0x000d:                case CHAR_CR:
5182                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5183                break;                break;
5184    
5185                case 0x000a:                case CHAR_LF:
5186                break;                break;
5187    
5188                case 0x000b:                case CHAR_VT:
5189                case 0x000c:                case CHAR_FF:
5190                case 0x0085:                case CHAR_NEL:
5191  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5192                case 0x2028:                case 0x2028:
5193                case 0x2029:                case 0x2029:
5194  #endif  #endif
# Line 5279  for (;;) Line 5201  for (;;)
5201              switch(c)              switch(c)
5202                {                {
5203                default: break;                default: break;
5204                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
5205                case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5206                case 0xa0:      /* NBSP */                HSPACE_MULTIBYTE_CASES:
 #ifdef COMPILE_PCRE16  
               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 */  
5207  #endif  #endif
5208                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5209                }                }
# Line 5308  for (;;) Line 5213  for (;;)
5213              switch(c)              switch(c)
5214                {                {
5215                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5216                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
5217                case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5218                case 0xa0:      /* NBSP */                HSPACE_MULTIBYTE_CASES:
 #ifdef COMPILE_PCRE16  
               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 */  
5219  #endif  #endif
5220                break;                break;
5221                }                }
# Line 5337  for (;;) Line 5225  for (;;)
5225              switch(c)              switch(c)
5226                {                {
5227                default: break;                default: break;
5228                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
5229                case 0x0b:      /* VT */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5230                case 0x0c:      /* FF */                VSPACE_MULTIBYTE_CASES:
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
 #ifdef COMPILE_PCRE16  
               case 0x2028:    /* LINE SEPARATOR */  
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5231  #endif  #endif
5232                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5233                }                }
# Line 5354  for (;;) Line 5237  for (;;)
5237              switch(c)              switch(c)
5238                {                {
5239                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5240                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
5241                case 0x0b:      /* VT */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5242                case 0x0c:      /* FF */                VSPACE_MULTIBYTE_CASES:
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
 #ifdef COMPILE_PCRE16  
               case 0x2028:    /* LINE SEPARATOR */  
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5243  #endif  #endif
5244                break;                break;
5245                }                }
# Line 5565  for (;;) Line 5443  for (;;)
5443              }              }
5444            break;            break;
5445    
5446              case PT_CLIST:
5447              for (i = min; i < max; i++)
5448                {
5449                const pcre_uint32 *cp;
5450                int len = 1;
5451                if (eptr >= md->end_subject)
5452                  {
5453                  SCHECK_PARTIAL();
5454                  break;
5455                  }
5456                GETCHARLENTEST(c, eptr, len);
5457                cp = PRIV(ucd_caseless_sets) + prop_value;
5458                for (;;)
5459                  {
5460                  if (c < *cp)
5461                    { if (prop_fail_result) break; else goto GOT_MAX; }
5462                  if (c == *cp++)
5463                    { if (prop_fail_result) goto GOT_MAX; else break; }
5464                  }
5465                eptr += len;
5466                }
5467              GOT_MAX:
5468              break;
5469    
5470            default:            default:
5471            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
5472            }            }
# Line 5588  for (;;) Line 5490  for (;;)
5490          {          {
5491          for (i = min; i < max; i++)          for (i = min; i < max; i++)
5492            {            {
           int len = 1;  
5493            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
5494              {              {
5495              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5496              break;              break;
5497              }              }
5498            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }            else
           if (UCD_CATEGORY(c) == ucp_M) break;  
           eptr += len;  
           while (eptr < md->end_subject)  
5499              {              {
5500              len = 1;              int lgb, rgb;
5501              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
5502              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
5503              eptr += len;              while (eptr < md->end_subject)
5504                  {
5505                  int len = 1;
5506                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5507                  rgb = UCD_GRAPHBREAK(c);
5508                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5509                  lgb = rgb;
5510                  eptr += len;
5511                  }
5512              }              }
5513            CHECK_PARTIAL();            CHECK_PARTIAL();
5514            }            }
# Line 5652  for (;;) Line 5558  for (;;)
5558                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5559                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5560                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5561                    *eptr == NLBLOCK->nl[0])                    RAWUCHAR(eptr) == NLBLOCK->nl[0])
5562                  {                  {
5563                  md->hitend = TRUE;                  md->hitend = TRUE;
5564                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 5678  for (;;) Line 5584  for (;;)
5584                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5585                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5586                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5587                    *eptr == NLBLOCK->nl[0])                    RAWUCHAR(eptr) == NLBLOCK->nl[0])
5588                  {                  {
5589                  md->hitend = TRUE;                  md->hitend = TRUE;
5590                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
# Line 5732  for (;;) Line 5638  for (;;)
5638                break;                break;
5639                }                }
5640              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5641              if (c == 0x000d)              if (c == CHAR_CR)
5642                {                {
5643                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5644                if (*eptr == 0x000a) eptr++;                if (RAWUCHAR(eptr) == CHAR_LF) eptr++;
5645                }                }
5646              else              else
5647                {                {
5648                if (c != 0x000a &&                if (c != CHAR_LF &&
5649                    (md->bsr_anycrlf ||                    (md->bsr_anycrlf ||
5650                     (c != 0x000b && c != 0x000c &&                     (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5651                      c != 0x0085 && c != 0x2028 && c != 0x2029)))  #ifndef EBCDIC
5652                        && c != 0x2028 && c != 0x2029
5653    #endif  /* Not EBCDIC */
5654                        )))
5655                  break;                  break;
5656                eptr += len;                eptr += len;
5657                }                }
# Line 5763  for (;;) Line 5672  for (;;)
5672              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5673              switch(c)              switch(c)
5674                {                {
5675                  HSPACE_CASES: gotspace = TRUE; break;
5676                default: gotspace = FALSE; break;                default: gotspace = FALSE; 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 */  
               gotspace = TRUE;  
               break;  
5677                }                }
5678              if (gotspace == (ctype == OP_NOT_HSPACE)) break;              if (gotspace == (ctype == OP_NOT_HSPACE)) break;
5679              eptr += len;              eptr += len;
# Line 5805  for (;;) Line 5694  for (;;)
5694              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5695              switch(c)              switch(c)
5696                {                {
5697                  VSPACE_CASES: gotspace = TRUE; break;
5698                default: gotspace = FALSE; break;                default: gotspace = FALSE; break;
               case 0x0a:      /* LF */  
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
               case 0x2028:    /* LINE SEPARATOR */  
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
               gotspace = TRUE;  
               break;  
5699                }                }
5700              if (gotspace == (ctype == OP_NOT_VSPACE)) break;              if (gotspace == (ctype == OP_NOT_VSPACE)) break;
5701              eptr += len;              eptr += len;
# Line 5928  for (;;) Line 5809  for (;;)
5809            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5810            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5811            BACKCHAR(eptr);            BACKCHAR(eptr);
5812            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && RAWUCHAR(eptr) == CHAR_NL &&
5813                eptr[-1] == '\r') eptr--;                RAWUCHAR(eptr - 1) == CHAR_CR) eptr--;
5814            }            }
5815          }          }
5816        else        else
# Line 5980  for (;;) Line 5861  for (;;)
5861                break;                break;
5862                }                }
5863              c = *eptr;              c = *eptr;
5864              if (c == 0x000d)              if (c == CHAR_CR)
5865                {                {
5866                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5867                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5868                }                }
5869              else              else
5870                {                {
5871                if (c != 0x000a && (md->bsr_anycrlf ||                if (c != CHAR_LF && (md->bsr_anycrlf ||
5872                  (c != 0x000b && c != 0x000c && c != 0x0085                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5873  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5874                  && c != 0x2028 && c != 0x2029                   && c != 0x2028 && c != 0x2029
5875  #endif  #endif
5876                  ))) break;                   ))) break;
5877                eptr++;                eptr++;
5878                }                }
5879              }              }
# Line 6006  for (;;) Line 5887  for (;;)
5887                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5888                break;                break;
5889                }                }
5890              c = *eptr;              switch(*eptr)
5891              if (c == 0x09 || c == 0x20 || c == 0xa0                {
5892  #ifdef COMPILE_PCRE16                default: eptr++; break;
5893                || c == 0x1680 || c == 0x180e || (c >= 0x2000 && c <= 0x200A)                HSPACE_BYTE_CASES:
5894                || c == 0x202f || c == 0x205f || c == 0x3000  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5895                  HSPACE_MULTIBYTE_CASES:
5896  #endif  #endif
5897                ) break;                goto ENDLOOP00;
5898              eptr++;                }
5899              }              }
5900              ENDLOOP00:
5901            break;            break;
5902    
5903            case OP_HSPACE:            case OP_HSPACE:
# Line 6025  for (;;) Line 5908  for (;;)
5908                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5909                break;                break;
5910                }                }
5911              c = *eptr;              switch(*eptr)
5912              if (c != 0x09 && c != 0x20 && c != 0xa0                {
5913  #ifdef COMPILE_PCRE16                default: goto ENDLOOP01;
5914                && c != 0x1680 && c != 0x180e && (c < 0x2000 || c > 0x200A)                HSPACE_BYTE_CASES:
5915                && c != 0x202f && c != 0x205f && c != 0x3000  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5916                  HSPACE_MULTIBYTE_CASES:
5917  #endif  #endif
5918                ) break;                eptr++; break;
5919              eptr++;                }
5920              }              }
5921              ENDLOOP01:
5922            break;            break;
5923    
5924            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
# Line 6044  for (;;) Line 5929  for (;;)
5929                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5930                break;                break;
5931                }                }
5932              c = *eptr;              switch(*eptr)
5933              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85                {
5934  #ifdef COMPILE_PCRE16                default: eptr++; break;
5935                || c == 0x2028 || c == 0x2029                VSPACE_BYTE_CASES:
5936    #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5937                  VSPACE_MULTIBYTE_CASES:
5938  #endif  #endif
5939                ) break;                goto ENDLOOP02;
5940              eptr++;                }
5941              }              }
5942              ENDLOOP02:
5943            break;            break;
5944    
5945            case OP_VSPACE:            case OP_VSPACE:
# Line 6062  for (;;) Line 5950  for (;;)
5950                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5951                break;                break;
5952                }                }
5953              c = *eptr;              switch(*eptr)
5954              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85                {
5955  #ifdef COMPILE_PCRE16                default: goto ENDLOOP03;
5956                && c != 0x2028 && c != 0x2029                VSPACE_BYTE_CASES:
5957    #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5958                  VSPACE_MULTIBYTE_CASES:
5959  #endif  #endif
5960                ) break;                eptr++; break;
5961              eptr++;                }
5962              }              }
5963              ENDLOOP03:
5964            break;            break;
5965    
5966            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
# Line 6166  for (;;) Line 6057  for (;;)
6057            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
6058            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
6059            eptr--;            eptr--;
6060            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_LF &&
6061                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
6062            }            }
6063          }          }
6064    
# Line 6217  switch (frame->Xwhere) Line 6108  switch (frame->Xwhere)
6108    LBL(32) LBL(34) LBL(42) LBL(46)    LBL(32) LBL(34) LBL(42) LBL(46)
6109  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
6110    LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)    LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
6111    LBL(59) LBL(60) LBL(61) LBL(62)    LBL(59) LBL(60) LBL(61) LBL(62) LBL(67)
6112  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
6113  #endif  /* SUPPORT_UTF */  #endif  /* SUPPORT_UTF */
6114    default:    default:
6115    DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));    DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
   
 printf("+++jump error in pcre match: label %d non-existent\n", frame->Xwhere);  
   
6116    return PCRE_ERROR_INTERNAL;    return PCRE_ERROR_INTERNAL;
6117    }    }
6118  #undef LBL  #undef LBL
# Line 6336  Returns:          > 0 => success; value Line 6224  Returns:          > 0 => success; value
6224                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
6225  */  */
6226    
6227  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
6228  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6229  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
6230    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
6231    int offsetcount)    int offsetcount)
6232  #else  #elif defined COMPILE_PCRE16
6233  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6234  pcre16_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,  pcre16_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,
6235    PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,
6236    int offsetcount)    int offsetcount)
6237    #elif defined COMPILE_PCRE32
6238    PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6239    pcre32_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,
6240      PCRE_SPTR32 subject, int length, int start_offset, int options, int *offsets,
6241      int offsetcount)
6242  #endif  #endif
6243  {  {
6244  int rc, ocount, arg_offset_max;  int rc, ocount, arg_offset_max;
# Line 6399  if ((options & ~PUBLIC_EXEC_OPTIONS) != Line 6292  if ((options & ~PUBLIC_EXEC_OPTIONS) !=
6292  if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))  if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))
6293    return PCRE_ERROR_NULL;    return PCRE_ERROR_NULL;
6294  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
6295    if (length < 0) return PCRE_ERROR_BADLENGTH;
6296  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
6297    
6298  /* Check that the first field in the block is the magic number. If it is not,  /* Check that the first field in the block is the magic number. If it is not,
# Line 6436  if (utf && (options & PCRE_NO_UTF8_CHECK Line 6330  if (utf && (options & PCRE_NO_UTF8_CHECK
6330        offsets[0] = erroroffset;        offsets[0] = erroroffset;
6331        offsets[1] = errorcode;        offsets[1] = errorcode;
6332        }        }
6333  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE8
     return (errorcode <= PCRE_UTF16_ERR1 && md->partial > 1)?  
       PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;  
 #else  
6334      return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?      return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?
6335        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
6336    #elif defined COMPILE_PCRE16
6337        return (errorcode <= PCRE_UTF16_ERR1 && md->partial > 1)?
6338          PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;
6339    #elif defined COMPILE_PCRE32
6340        return PCRE_ERROR_BADUTF32;
6341  #endif  #endif
6342      }      }
6343    #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
6344    /* Check that a start_offset points to the start of a UTF character. */    /* Check that a start_offset points to the start of a UTF character. */
6345    if (start_offset > 0 && start_offset < length &&    if (start_offset > 0 && start_offset < length &&
6346        NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))        NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))
6347      return PCRE_ERROR_BADUTF8_OFFSET;      return PCRE_ERROR_BADUTF8_OFFSET;
6348    #endif
6349    }    }
6350  #endif  #endif
6351    
# Line 6462  if (extra_data != NULL Line 6359  if (extra_data != NULL
6359      && (extra_data->flags & (PCRE_EXTRA_EXECUTABLE_JIT |      && (extra_data->flags & (PCRE_EXTRA_EXECUTABLE_JIT |
6360                               PCRE_EXTRA_TABLES)) == PCRE_EXTRA_EXECUTABLE_JIT                               PCRE_EXTRA_TABLES)) == PCRE_EXTRA_EXECUTABLE_JIT
6361      && extra_data->executable_jit != NULL      && extra_data->executable_jit != NULL
6362      && (options & ~(PCRE_NO_UTF8_CHECK | PCRE_NOTBOL | PCRE_NOTEOL |      && (options & ~PUBLIC_JIT_EXEC_OPTIONS) == 0)
                     PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |  
                     PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)  
6363    {    {
6364    rc = PRIV(jit_exec)(re, extra_data, (const pcre_uchar *)subject, length,    rc = PRIV(jit_exec)(extra_data, (const pcre_uchar *)subject, length,
6365         start_offset, options, offsets, offsetcount);         start_offset, options, offsets, offsetcount);
6366    
6367    /* PCRE_ERROR_NULL means that the selected normal or partial matching    /* PCRE_ERROR_NULL means that the selected normal or partial matching
6368    mode is not compiled. In this case we simply fallback to interpreter. */    mode is not compiled. In this case we simply fallback to interpreter. */
6369    
6370    if (rc != PCRE_ERROR_NULL) return rc;    if (rc != PCRE_ERROR_JIT_BADOPTION) return rc;
6371    }    }
6372  #endif  #endif
6373    
# Line 6756  for(;;) Line 6651  for(;;)
6651    
6652      if (has_first_char)      if (has_first_char)
6653        {        {
6654          pcre_uchar smc;
6655    
6656        if (first_char != first_char2)        if (first_char != first_char2)
6657          while (start_match < end_subject &&          while (start_match < end_subject &&
6658              *start_match != first_char && *start_match != first_char2)            (smc = RAWUCHARTEST(start_match)) != first_char && smc != first_char2)
6659            start_match++;            start_match++;
6660        else        else
6661          while (start_match < end_subject && *start_match != first_char)          while (start_match < end_subject && RAWUCHARTEST(start_match) != first_char)
6662            start_match++;            start_match++;
6663        }        }
6664    
# Line 6793  for(;;) Line 6690  for(;;)
6690          if (start_match[-1] == CHAR_CR &&          if (start_match[-1] == CHAR_CR &&
6691               (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&               (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
6692               start_match < end_subject &&               start_match < end_subject &&
6693               *start_match == CHAR_NL)               RAWUCHARTEST(start_match) == CHAR_NL)
6694            start_match++;            start_match++;
6695          }          }
6696        }        }
# Line 6804  for(;;) Line 6701  for(;;)
6701        {        {
6702        while (start_match < end_subject)        while (start_match < end_subject)
6703          {          {
6704          register unsigned int c = *start_match;          register pcre_uint32 c = RAWUCHARTEST(start_match);
6705  #ifndef COMPILE_PCRE8  #ifndef COMPILE_PCRE8
6706          if (c > 255) c = 255;          if (c > 255) c = 255;
6707  #endif  #endif
# Line 6872  for(;;) Line 6769  for(;;)
6769            {            {
6770            while (p < end_subject)            while (p < end_subject)
6771              {              {
6772              register int pp = *p++;              register pcre_uint32 pp = RAWUCHARINCTEST(p);
6773              if (pp == req_char || pp == req_char2) { p--; break; }              if (pp == req_char || pp == req_char2) { p--; break; }
6774              }              }
6775            }            }
# Line 6880  for(;;) Line 6777  for(;;)
6777            {            {
6778            while (p < end_subject)            while (p < end_subject)
6779              {              {
6780              if (*p++ == req_char) { p--; break; }              if (RAWUCHARINCTEST(p) == req_char) { p--; break; }
6781              }              }
6782            }            }
6783    

Legend:
Removed from v.976  
changed lines
  Added in v.1238

  ViewVC Help
Powered by ViewVC 1.1.5