/[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 1055 by chpe, Tue Oct 16 15:53:30 2012 UTC
# Line 180  if (caseless) Line 180  if (caseless)
180    if (md->utf)    if (md->utf)
181      {      {
182      /* 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
183      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
184      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.
185      (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
186      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
187      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
188      reference, not along the subject (earlier code did this wrong). */      length along the reference, not along the subject (earlier code did this
189        wrong). */
190    
191      PCRE_PUCHAR endptr = p + length;      PCRE_PUCHAR endptr = p + length;
192      while (p < endptr)      while (p < endptr)
193        {        {
194        int c, d;        unsigned int c, d;
195          const ucd_record *ur;
196        if (eptr >= md->end_subject) return -2;   /* Partial match */        if (eptr >= md->end_subject) return -2;   /* Partial match */
197        GETCHARINC(c, eptr);        GETCHARINC(c, eptr);
198        GETCHARINC(d, p);        GETCHARINC(d, p);
199        if (c != d && c != UCD_OTHERCASE(d)) return -1;        ur = GET_UCD(d);
200          if (c != d && c != d + ur->other_case)
201            {
202            const pcre_uint32 *pp = PRIV(ucd_caseless_sets) + ur->caseset;
203            for (;;)
204              {
205              if (c < *pp) return -1;
206              if (c == *pp++) break;
207              }
208            }
209        }        }
210      }      }
211    else    else
# Line 1262  for (;;) Line 1273  for (;;)
1273          cb.version          = 2;   /* Version 1 of the callout block */          cb.version          = 2;   /* Version 1 of the callout block */
1274          cb.callout_number   = ecode[LINK_SIZE+2];          cb.callout_number   = ecode[LINK_SIZE+2];
1275          cb.offset_vector    = md->offset_vector;          cb.offset_vector    = md->offset_vector;
1276  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
1277          cb.subject          = (PCRE_SPTR)md->start_subject;          cb.subject          = (PCRE_SPTR)md->start_subject;
1278  #else  #elif defined COMPILE_PCRE16
1279          cb.subject          = (PCRE_SPTR16)md->start_subject;          cb.subject          = (PCRE_SPTR16)md->start_subject;
1280    #elif defined COMPILE_PCRE32
1281            cb.subject          = (PCRE_SPTR32)md->start_subject;
1282  #endif  #endif
1283          cb.subject_length   = (int)(md->end_subject - md->start_subject);          cb.subject_length   = (int)(md->end_subject - md->start_subject);
1284          cb.start_match      = (int)(mstart - md->start_subject);          cb.start_match      = (int)(mstart - md->start_subject);
# Line 1685  for (;;) Line 1698  for (;;)
1698        cb.version          = 2;   /* Version 1 of the callout block */        cb.version          = 2;   /* Version 1 of the callout block */
1699        cb.callout_number   = ecode[1];        cb.callout_number   = ecode[1];
1700        cb.offset_vector    = md->offset_vector;        cb.offset_vector    = md->offset_vector;
1701  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
1702        cb.subject          = (PCRE_SPTR)md->start_subject;        cb.subject          = (PCRE_SPTR)md->start_subject;
1703  #else  #elif defined COMPILE_PCRE16
1704        cb.subject          = (PCRE_SPTR16)md->start_subject;        cb.subject          = (PCRE_SPTR16)md->start_subject;
1705    #elif defined COMPILE_PCRE32
1706          cb.subject          = (PCRE_SPTR32)md->start_subject;
1707  #endif  #endif
1708        cb.subject_length   = (int)(md->end_subject - md->start_subject);        cb.subject_length   = (int)(md->end_subject - md->start_subject);
1709        cb.start_match      = (int)(mstart - md->start_subject);        cb.start_match      = (int)(mstart - md->start_subject);
# Line 2415  for (;;) Line 2430  for (;;)
2430        {        {
2431        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2432    
2433        case 0x000d:        case CHAR_CR:
2434        if (eptr >= md->end_subject)        if (eptr >= md->end_subject)
2435          {          {
2436          SCHECK_PARTIAL();          SCHECK_PARTIAL();
2437          }          }
2438        else if (*eptr == 0x0a) eptr++;        else if (*eptr == CHAR_LF) eptr++;
2439        break;        break;
2440    
2441        case 0x000a:        case CHAR_LF:
2442        break;        break;
2443    
2444        case 0x000b:        case CHAR_VT:
2445        case 0x000c:        case CHAR_FF:
2446        case 0x0085:        case CHAR_NEL:
2447    #ifndef EBCDIC
2448        case 0x2028:        case 0x2028:
2449        case 0x2029:        case 0x2029:
2450    #endif  /* Not EBCDIC */
2451        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2452        break;        break;
2453        }        }
# Line 2446  for (;;) Line 2463  for (;;)
2463      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2464      switch(c)      switch(c)
2465        {        {
2466          HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
2467        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);  
2468        }        }
2469      ecode++;      ecode++;
2470      break;      break;
# Line 2480  for (;;) Line 2478  for (;;)
2478      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2479      switch(c)      switch(c)
2480        {        {
2481          HSPACE_CASES: break;  /* Byte and multibyte cases */
2482        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;  
2483        }        }
2484      ecode++;      ecode++;
2485      break;      break;
# Line 2514  for (;;) Line 2493  for (;;)
2493      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2494      switch(c)      switch(c)
2495        {        {
2496          VSPACE_CASES: RRETURN(MATCH_NOMATCH);
2497        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);  
2498        }        }
2499      ecode++;      ecode++;
2500      break;      break;
# Line 2536  for (;;) Line 2508  for (;;)
2508      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2509      switch(c)      switch(c)
2510        {        {
2511          VSPACE_CASES: break;
2512        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;  
2513        }        }
2514      ecode++;      ecode++;
2515      break;      break;
# Line 2562  for (;;) Line 2527  for (;;)
2527        }        }
2528      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2529        {        {
2530          const pcre_uint32 *cp;
2531        const ucd_record *prop = GET_UCD(c);        const ucd_record *prop = GET_UCD(c);
2532    
2533        switch(ecode[1])        switch(ecode[1])
# Line 2622  for (;;) Line 2588  for (;;)
2588            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2589          break;          break;
2590    
2591            case PT_CLIST:
2592            cp = PRIV(ucd_caseless_sets) + prop->caseset;
2593            for (;;)
2594              {
2595              if (c < *cp)
2596                { if (op == OP_PROP) { RRETURN(MATCH_NOMATCH); } else break; }
2597              if (c == *cp++)
2598                { if (op == OP_PROP) break; else { RRETURN(MATCH_NOMATCH); } }
2599              }
2600            break;
2601    
2602          /* This should never occur */          /* This should never occur */
2603    
2604          default:          default:
# Line 2641  for (;;) Line 2618  for (;;)
2618        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2619        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2620        }        }
2621      GETCHARINCTEST(c, eptr);      else
     if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
     while (eptr < md->end_subject)  
2622        {        {
2623        int len = 1;        int lgb, rgb;
2624        if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }        GETCHARINCTEST(c, eptr);
2625        if (UCD_CATEGORY(c) != ucp_M) break;        lgb = UCD_GRAPHBREAK(c);
2626        eptr += len;        while (eptr < md->end_subject)
2627            {
2628            int len = 1;
2629            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2630            rgb = UCD_GRAPHBREAK(c);
2631            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2632            lgb = rgb;
2633            eptr += len;
2634            }
2635        }        }
2636      CHECK_PARTIAL();      CHECK_PARTIAL();
2637      ecode++;      ecode++;
2638      break;      break;
2639  #endif  #endif  /* SUPPORT_UCP */
2640    
2641    
2642      /* 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 4206  for (;;) Line 4189  for (;;)
4189                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4190              }              }
4191            break;            break;
4192    
4193              case PT_CLIST:
4194              for (i = 1; i <= min; i++)
4195                {
4196                const pcre_uint32 *cp;
4197                if (eptr >= md->end_subject)
4198                  {
4199                  SCHECK_PARTIAL();
4200                  RRETURN(MATCH_NOMATCH);
4201                  }
4202                GETCHARINCTEST(c, eptr);
4203                cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);
4204                for (;;)
4205                  {
4206                  if (c < *cp)
4207                    { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4208                  if (c == *cp++)
4209                    { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4210                  }
4211                }
4212              break;
4213    
4214            /* This should not occur */            /* This should not occur */
4215    
4216            default:            default:
# Line 4226  for (;;) Line 4230  for (;;)
4230              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4231              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4232              }              }
4233            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4234              {              {
4235              int len = 1;              int lgb, rgb;
4236              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4237              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4238              eptr += len;             while (eptr < md->end_subject)
4239                  {
4240                  int len = 1;
4241                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4242                  rgb = UCD_GRAPHBREAK(c);
4243                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4244                  lgb = rgb;
4245                  eptr += len;
4246                  }
4247              }              }
4248            CHECK_PARTIAL();            CHECK_PARTIAL();
4249            }            }
# Line 4301  for (;;) Line 4311  for (;;)
4311              {              {
4312              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4313    
4314              case 0x000d:              case CHAR_CR:
4315              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4316              break;              break;
4317    
4318              case 0x000a:              case CHAR_LF:
4319              break;              break;
4320    
4321              case 0x000b:              case CHAR_VT:
4322              case 0x000c:              case CHAR_FF:
4323              case 0x0085:              case CHAR_NEL:
4324    #ifndef EBCDIC
4325              case 0x2028:              case 0x2028:
4326              case 0x2029:              case 0x2029:
4327    #endif  /* Not EBCDIC */
4328              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4329              break;              break;
4330              }              }
# Line 4330  for (;;) Line 4342  for (;;)
4342            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4343            switch(c)            switch(c)
4344              {              {
4345                HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
4346              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);  
4347              }              }
4348            }            }
4349          break;          break;
# Line 4366  for (;;) Line 4359  for (;;)
4359            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4360            switch(c)            switch(c)
4361              {              {
4362                HSPACE_CASES: break;  /* Byte and multibyte cases */
4363              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;  
4364              }              }
4365            }            }
4366          break;          break;
# Line 4402  for (;;) Line 4376  for (;;)
4376            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4377            switch(c)            switch(c)
4378              {              {
4379                VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4380              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);  
4381              }              }
4382            }            }
4383          break;          break;
# Line 4426  for (;;) Line 4393  for (;;)
4393            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4394            switch(c)            switch(c)
4395              {              {
4396                VSPACE_CASES: break;
4397              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;  
4398              }              }
4399            }            }
4400          break;          break;
# Line 4592  for (;;) Line 4552  for (;;)
4552              {              {
4553              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4554    
4555              case 0x000d:              case CHAR_CR:
4556              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4557              break;              break;
4558    
4559              case 0x000a:              case CHAR_LF:
4560              break;              break;
4561    
4562              case 0x000b:              case CHAR_VT:
4563              case 0x000c:              case CHAR_FF:
4564              case 0x0085:              case CHAR_NEL:
4565  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4566              case 0x2028:              case 0x2028:
4567              case 0x2029:              case 0x2029:
4568  #endif  #endif
# Line 4623  for (;;) Line 4583  for (;;)
4583            switch(*eptr++)            switch(*eptr++)
4584              {              {
4585              default: break;              default: break;
4586              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
4587              case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4588              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 */  
4589  #endif  #endif
4590              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4591              }              }
# Line 4660  for (;;) Line 4603  for (;;)
4603            switch(*eptr++)            switch(*eptr++)
4604              {              {
4605              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4606              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
4607              case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4608              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 */  
4609  #endif  #endif
4610              break;              break;
4611              }              }
# Line 4696  for (;;) Line 4622  for (;;)
4622              }              }
4623            switch(*eptr++)            switch(*eptr++)
4624              {              {
4625              default: break;              VSPACE_BYTE_CASES:
4626              case 0x0a:      /* LF */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4627              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 */  
4628  #endif  #endif
4629              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4630                default: break;
4631              }              }
4632            }            }
4633          break;          break;
# Line 4722  for (;;) Line 4643  for (;;)
4643            switch(*eptr++)            switch(*eptr++)
4644              {              {
4645              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4646              case 0x0a:      /* LF */              VSPACE_BYTE_CASES:
4647              case 0x0b:      /* VT */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
4648              case 0x0c:      /* FF */              VSPACE_MULTIBYTE_CASES:
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
 #ifdef COMPILE_PCRE16  
             case 0x2028:    /* LINE SEPARATOR */  
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4649  #endif  #endif
4650              break;              break;
4651              }              }
# Line 5007  for (;;) Line 4923  for (;;)
4923              }              }
4924            /* Control never gets here */            /* Control never gets here */
4925    
4926            /* This should never occur */            case PT_CLIST:
4927              for (fi = min;; fi++)
4928                {
4929                const pcre_uint32 *cp;
4930                RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);
4931                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4932                if (fi >= max) RRETURN(MATCH_NOMATCH);
4933                if (eptr >= md->end_subject)
4934                  {
4935                  SCHECK_PARTIAL();
4936                  RRETURN(MATCH_NOMATCH);
4937                  }
4938                GETCHARINCTEST(c, eptr);
4939                cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);
4940                for (;;)
4941                  {
4942                  if (c < *cp)
4943                    { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4944                  if (c == *cp++)
4945                    { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4946                  }
4947                }
4948              /* Control never gets here */
4949    
4950              /* This should never occur */
4951            default:            default:
4952            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4953            }            }
# Line 5029  for (;;) Line 4968  for (;;)
4968              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4969              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4970              }              }
4971            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4972              {              {
4973              int len = 1;              int lgb, rgb;
4974              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4975              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4976              eptr += len;              while (eptr < md->end_subject)
4977                  {
4978                  int len = 1;
4979                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4980                  rgb = UCD_GRAPHBREAK(c);
4981                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4982                  lgb = rgb;
4983                  eptr += len;
4984                  }
4985              }              }
4986            CHECK_PARTIAL();            CHECK_PARTIAL();
4987            }            }
# Line 5082  for (;;) Line 5027  for (;;)
5027              switch(c)              switch(c)
5028                {                {
5029                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5030                case 0x000d:                case CHAR_CR:
5031                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5032                break;                break;
5033                case 0x000a:  
5034                  case CHAR_LF:
5035                break;                break;
5036    
5037                case 0x000b:                case CHAR_VT:
5038                case 0x000c:                case CHAR_FF:
5039                case 0x0085:                case CHAR_NEL:
5040    #ifndef EBCDIC
5041                case 0x2028:                case 0x2028:
5042                case 0x2029:                case 0x2029:
5043    #endif  /* Not EBCDIC */
5044                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5045                break;                break;
5046                }                }
# Line 5101  for (;;) Line 5049  for (;;)
5049              case OP_NOT_HSPACE:              case OP_NOT_HSPACE:
5050              switch(c)              switch(c)
5051                {                {
5052                  HSPACE_CASES: RRETURN(MATCH_NOMATCH);
5053                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);  
5054                }                }
5055              break;              break;
5056    
5057              case OP_HSPACE:              case OP_HSPACE:
5058              switch(c)              switch(c)
5059                {                {
5060                  HSPACE_CASES: break;
5061                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;  
5062                }                }
5063              break;              break;
5064    
5065              case OP_NOT_VSPACE:              case OP_NOT_VSPACE:
5066              switch(c)              switch(c)
5067                {                {
5068                  VSPACE_CASES: RRETURN(MATCH_NOMATCH);
5069                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);  
5070                }                }
5071              break;              break;
5072    
5073              case OP_VSPACE:              case OP_VSPACE:
5074              switch(c)              switch(c)
5075                {                {
5076                  VSPACE_CASES: break;
5077                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;  
5078                }                }
5079              break;              break;
5080    
# Line 5256  for (;;) Line 5152  for (;;)
5152              switch(c)              switch(c)
5153                {                {
5154                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5155                case 0x000d:                case CHAR_CR:
5156                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5157                break;                break;
5158    
5159                case 0x000a:                case CHAR_LF:
5160                break;                break;
5161    
5162                case 0x000b:                case CHAR_VT:
5163                case 0x000c:                case CHAR_FF:
5164                case 0x0085:                case CHAR_NEL:
5165  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5166                case 0x2028:                case 0x2028:
5167                case 0x2029:                case 0x2029:
5168  #endif  #endif
# Line 5279  for (;;) Line 5175  for (;;)
5175              switch(c)              switch(c)
5176                {                {
5177                default: break;                default: break;
5178                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
5179                case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5180                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 */  
5181  #endif  #endif
5182                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5183                }                }
# Line 5308  for (;;) Line 5187  for (;;)
5187              switch(c)              switch(c)
5188                {                {
5189                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5190                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
5191                case 0x20:      /* SPACE */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5192                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 */  
5193  #endif  #endif
5194                break;                break;
5195                }                }
# Line 5337  for (;;) Line 5199  for (;;)
5199              switch(c)              switch(c)
5200                {                {
5201                default: break;                default: break;
5202                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
5203                case 0x0b:      /* VT */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5204                case 0x0c:      /* FF */                VSPACE_MULTIBYTE_CASES:
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
 #ifdef COMPILE_PCRE16  
               case 0x2028:    /* LINE SEPARATOR */  
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5205  #endif  #endif
5206                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5207                }                }
# Line 5354  for (;;) Line 5211  for (;;)
5211              switch(c)              switch(c)
5212                {                {
5213                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5214                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
5215                case 0x0b:      /* VT */  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5216                case 0x0c:      /* FF */                VSPACE_MULTIBYTE_CASES:
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
 #ifdef COMPILE_PCRE16  
               case 0x2028:    /* LINE SEPARATOR */  
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5217  #endif  #endif
5218                break;                break;
5219                }                }
# Line 5564  for (;;) Line 5416  for (;;)
5416              eptr+= len;              eptr+= len;
5417              }              }
5418            break;            break;
5419    
5420              case PT_CLIST:
5421              for (i = min; i < max; i++)
5422                {
5423                const pcre_uint32 *cp;
5424                int len = 1;
5425                if (eptr >= md->end_subject)
5426                  {
5427                  SCHECK_PARTIAL();
5428                  break;
5429                  }
5430                GETCHARLENTEST(c, eptr, len);
5431                cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);
5432                for (;;)
5433                  {
5434                  if (c < *cp)
5435                    { if (prop_fail_result) break; else goto GOT_MAX; }
5436                  if (c == *cp++)
5437                    { if (prop_fail_result) goto GOT_MAX; else break; }
5438                  }
5439                eptr += len;
5440                }
5441              GOT_MAX:
5442              break;
5443    
5444            default:            default:
5445            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
# Line 5588  for (;;) Line 5464  for (;;)
5464          {          {
5465          for (i = min; i < max; i++)          for (i = min; i < max; i++)
5466            {            {
           int len = 1;  
5467            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
5468              {              {
5469              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5470              break;              break;
5471              }              }
5472            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }            else
           if (UCD_CATEGORY(c) == ucp_M) break;  
           eptr += len;  
           while (eptr < md->end_subject)  
5473              {              {
5474              len = 1;              int lgb, rgb;
5475              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
5476              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
5477              eptr += len;              while (eptr < md->end_subject)
5478                  {
5479                  int len = 1;
5480                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5481                  rgb = UCD_GRAPHBREAK(c);
5482                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5483                  lgb = rgb;
5484                  eptr += len;
5485                  }
5486              }              }
5487            CHECK_PARTIAL();            CHECK_PARTIAL();
5488            }            }
# Line 5732  for (;;) Line 5612  for (;;)
5612                break;                break;
5613                }                }
5614              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5615              if (c == 0x000d)              if (c == CHAR_CR)
5616                {                {
5617                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5618                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5619                }                }
5620              else              else
5621                {                {
5622                if (c != 0x000a &&                if (c != CHAR_LF &&
5623                    (md->bsr_anycrlf ||                    (md->bsr_anycrlf ||
5624                     (c != 0x000b && c != 0x000c &&                     (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5625                      c != 0x0085 && c != 0x2028 && c != 0x2029)))  #ifndef EBCDIC
5626                        && c != 0x2028 && c != 0x2029
5627    #endif  /* Not EBCDIC */
5628                        )))
5629                  break;                  break;
5630                eptr += len;                eptr += len;
5631                }                }
# Line 5763  for (;;) Line 5646  for (;;)
5646              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5647              switch(c)              switch(c)
5648                {                {
5649                  HSPACE_CASES: gotspace = TRUE; break;
5650                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;  
5651                }                }
5652              if (gotspace == (ctype == OP_NOT_HSPACE)) break;              if (gotspace == (ctype == OP_NOT_HSPACE)) break;
5653              eptr += len;              eptr += len;
# Line 5805  for (;;) Line 5668  for (;;)
5668              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5669              switch(c)              switch(c)
5670                {                {
5671                  VSPACE_CASES: gotspace = TRUE; break;
5672                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;  
5673                }                }
5674              if (gotspace == (ctype == OP_NOT_VSPACE)) break;              if (gotspace == (ctype == OP_NOT_VSPACE)) break;
5675              eptr += len;              eptr += len;
# Line 5928  for (;;) Line 5783  for (;;)
5783            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5784            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5785            BACKCHAR(eptr);            BACKCHAR(eptr);
5786            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_NL &&
5787                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
5788            }            }
5789          }          }
5790        else        else
# Line 5980  for (;;) Line 5835  for (;;)
5835                break;                break;
5836                }                }
5837              c = *eptr;              c = *eptr;
5838              if (c == 0x000d)              if (c == CHAR_CR)
5839                {                {
5840                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5841                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5842                }                }
5843              else              else
5844                {                {
5845                if (c != 0x000a && (md->bsr_anycrlf ||                if (c != CHAR_LF && (md->bsr_anycrlf ||
5846                  (c != 0x000b && c != 0x000c && c != 0x0085                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5847  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5848                  && c != 0x2028 && c != 0x2029                   && c != 0x2028 && c != 0x2029
5849  #endif  #endif
5850                  ))) break;                   ))) break;
5851                eptr++;                eptr++;
5852                }                }
5853              }              }
# Line 6006  for (;;) Line 5861  for (;;)
5861                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5862                break;                break;
5863                }                }
5864              c = *eptr;              switch(*eptr)
5865              if (c == 0x09 || c == 0x20 || c == 0xa0                {
5866  #ifdef COMPILE_PCRE16                default: eptr++; break;
5867                || c == 0x1680 || c == 0x180e || (c >= 0x2000 && c <= 0x200A)                HSPACE_BYTE_CASES:
5868                || c == 0x202f || c == 0x205f || c == 0x3000  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5869                  HSPACE_MULTIBYTE_CASES:
5870  #endif  #endif
5871                ) break;                goto ENDLOOP00;
5872              eptr++;                }
5873              }              }
5874              ENDLOOP00:
5875            break;            break;
5876    
5877            case OP_HSPACE:            case OP_HSPACE:
# Line 6025  for (;;) Line 5882  for (;;)
5882                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5883                break;                break;
5884                }                }
5885              c = *eptr;              switch(*eptr)
5886              if (c != 0x09 && c != 0x20 && c != 0xa0                {
5887  #ifdef COMPILE_PCRE16                default: goto ENDLOOP01;
5888                && c != 0x1680 && c != 0x180e && (c < 0x2000 || c > 0x200A)                HSPACE_BYTE_CASES:
5889                && c != 0x202f && c != 0x205f && c != 0x3000  #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5890                  HSPACE_MULTIBYTE_CASES:
5891  #endif  #endif
5892                ) break;                eptr++; break;
5893              eptr++;                }
5894              }              }
5895              ENDLOOP01:
5896            break;            break;
5897    
5898            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
# Line 6044  for (;;) Line 5903  for (;;)
5903                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5904                break;                break;
5905                }                }
5906              c = *eptr;              switch(*eptr)
5907              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85                {
5908  #ifdef COMPILE_PCRE16                default: eptr++; break;
5909                || c == 0x2028 || c == 0x2029                VSPACE_BYTE_CASES:
5910    #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5911                  VSPACE_MULTIBYTE_CASES:
5912  #endif  #endif
5913                ) break;                goto ENDLOOP02;
5914              eptr++;                }
5915              }              }
5916              ENDLOOP02:
5917            break;            break;
5918    
5919            case OP_VSPACE:            case OP_VSPACE:
# Line 6062  for (;;) Line 5924  for (;;)
5924                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5925                break;                break;
5926                }                }
5927              c = *eptr;              switch(*eptr)
5928              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85                {
5929  #ifdef COMPILE_PCRE16                default: goto ENDLOOP03;
5930                && c != 0x2028 && c != 0x2029                VSPACE_BYTE_CASES:
5931    #if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
5932                  VSPACE_MULTIBYTE_CASES:
5933  #endif  #endif
5934                ) break;                eptr++; break;
5935              eptr++;                }
5936              }              }
5937              ENDLOOP03:
5938            break;            break;
5939    
5940            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
# Line 6166  for (;;) Line 6031  for (;;)
6031            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
6032            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
6033            eptr--;            eptr--;
6034            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_LF &&
6035                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
6036            }            }
6037          }          }
6038    
# Line 6336  Returns:          > 0 => success; value Line 6201  Returns:          > 0 => success; value
6201                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
6202  */  */
6203    
6204  #ifdef COMPILE_PCRE8  #if defined COMPILE_PCRE8
6205  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6206  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
6207    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
6208    int offsetcount)    int offsetcount)
6209  #else  #elif defined COMPILE_PCRE16
6210  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6211  pcre16_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,  pcre16_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,
6212    PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,
6213    int offsetcount)    int offsetcount)
6214    #elif defined COMPILE_PCRE32
6215    PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
6216    pcre32_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,
6217      PCRE_SPTR32 subject, int length, int start_offset, int options, int *offsets,
6218      int offsetcount)
6219  #endif  #endif
6220  {  {
6221  int rc, ocount, arg_offset_max;  int rc, ocount, arg_offset_max;
# Line 6436  if (utf && (options & PCRE_NO_UTF8_CHECK Line 6306  if (utf && (options & PCRE_NO_UTF8_CHECK
6306        offsets[0] = erroroffset;        offsets[0] = erroroffset;
6307        offsets[1] = errorcode;        offsets[1] = errorcode;
6308        }        }
6309  #ifdef COMPILE_PCRE16  #if defined COMPILE_PCRE8
     return (errorcode <= PCRE_UTF16_ERR1 && md->partial > 1)?  
       PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;  
 #else  
6310      return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?      return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?
6311        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;        PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
6312    #elif defined COMPILE_PCRE16
6313        return (errorcode <= PCRE_UTF16_ERR1 && md->partial > 1)?
6314          PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;
6315    #elif defined COMPILE_PCRE32
6316        return PCRE_ERROR_BADUTF32;
6317  #endif  #endif
6318      }      }
6319    #if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
6320    /* 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. */
6321    if (start_offset > 0 && start_offset < length &&    if (start_offset > 0 && start_offset < length &&
6322        NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))        NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))
6323      return PCRE_ERROR_BADUTF8_OFFSET;      return PCRE_ERROR_BADUTF8_OFFSET;
6324    #endif
6325    }    }
6326  #endif  #endif
6327    

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

  ViewVC Help
Powered by ViewVC 1.1.5