/[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 1047 by zherczeg, Fri Sep 28 15:06:38 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 2415  for (;;) Line 2426  for (;;)
2426        {        {
2427        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2428    
2429        case 0x000d:        case CHAR_CR:
2430        if (eptr >= md->end_subject)        if (eptr >= md->end_subject)
2431          {          {
2432          SCHECK_PARTIAL();          SCHECK_PARTIAL();
2433          }          }
2434        else if (*eptr == 0x0a) eptr++;        else if (*eptr == CHAR_LF) eptr++;
2435        break;        break;
2436    
2437        case 0x000a:        case CHAR_LF:
2438        break;        break;
2439    
2440        case 0x000b:        case CHAR_VT:
2441        case 0x000c:        case CHAR_FF:
2442        case 0x0085:        case CHAR_NEL:
2443    #ifndef EBCDIC
2444        case 0x2028:        case 0x2028:
2445        case 0x2029:        case 0x2029:
2446    #endif  /* Not EBCDIC */
2447        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2448        break;        break;
2449        }        }
# Line 2446  for (;;) Line 2459  for (;;)
2459      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2460      switch(c)      switch(c)
2461        {        {
2462          HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
2463        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);  
2464        }        }
2465      ecode++;      ecode++;
2466      break;      break;
# Line 2480  for (;;) Line 2474  for (;;)
2474      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2475      switch(c)      switch(c)
2476        {        {
2477          HSPACE_CASES: break;  /* Byte and multibyte cases */
2478        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;  
2479        }        }
2480      ecode++;      ecode++;
2481      break;      break;
# Line 2514  for (;;) Line 2489  for (;;)
2489      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2490      switch(c)      switch(c)
2491        {        {
2492          VSPACE_CASES: RRETURN(MATCH_NOMATCH);
2493        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);  
2494        }        }
2495      ecode++;      ecode++;
2496      break;      break;
# Line 2536  for (;;) Line 2504  for (;;)
2504      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2505      switch(c)      switch(c)
2506        {        {
2507          VSPACE_CASES: break;
2508        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;  
2509        }        }
2510      ecode++;      ecode++;
2511      break;      break;
# Line 2562  for (;;) Line 2523  for (;;)
2523        }        }
2524      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2525        {        {
2526          const pcre_uint32 *cp;
2527        const ucd_record *prop = GET_UCD(c);        const ucd_record *prop = GET_UCD(c);
2528    
2529        switch(ecode[1])        switch(ecode[1])
# Line 2622  for (;;) Line 2584  for (;;)
2584            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2585          break;          break;
2586    
2587            case PT_CLIST:
2588            cp = PRIV(ucd_caseless_sets) + prop->caseset;
2589            for (;;)
2590              {
2591              if (c < *cp)
2592                { if (op == OP_PROP) { RRETURN(MATCH_NOMATCH); } else break; }
2593              if (c == *cp++)
2594                { if (op == OP_PROP) break; else { RRETURN(MATCH_NOMATCH); } }
2595              }
2596            break;
2597    
2598          /* This should never occur */          /* This should never occur */
2599    
2600          default:          default:
# Line 2641  for (;;) Line 2614  for (;;)
2614        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2615        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2616        }        }
2617      GETCHARINCTEST(c, eptr);      else
     if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
     while (eptr < md->end_subject)  
2618        {        {
2619        int len = 1;        int lgb, rgb;
2620        if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }        GETCHARINCTEST(c, eptr);
2621        if (UCD_CATEGORY(c) != ucp_M) break;        lgb = UCD_GRAPHBREAK(c);
2622        eptr += len;        while (eptr < md->end_subject)
2623            {
2624            int len = 1;
2625            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2626            rgb = UCD_GRAPHBREAK(c);
2627            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2628            lgb = rgb;
2629            eptr += len;
2630            }
2631        }        }
2632      CHECK_PARTIAL();      CHECK_PARTIAL();
2633      ecode++;      ecode++;
2634      break;      break;
2635  #endif  #endif  /* SUPPORT_UCP */
2636    
2637    
2638      /* 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 4185  for (;;)
4185                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4186              }              }
4187            break;            break;
4188    
4189              case PT_CLIST:
4190              for (i = 1; i <= min; i++)
4191                {
4192                const pcre_uint32 *cp;
4193                if (eptr >= md->end_subject)
4194                  {
4195                  SCHECK_PARTIAL();
4196                  RRETURN(MATCH_NOMATCH);
4197                  }
4198                GETCHARINCTEST(c, eptr);
4199                cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);
4200                for (;;)
4201                  {
4202                  if (c < *cp)
4203                    { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4204                  if (c == *cp++)
4205                    { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4206                  }
4207                }
4208              break;
4209    
4210            /* This should not occur */            /* This should not occur */
4211    
4212            default:            default:
# Line 4226  for (;;) Line 4226  for (;;)
4226              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4227              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4228              }              }
4229            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4230              {              {
4231              int len = 1;              int lgb, rgb;
4232              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4233              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4234              eptr += len;             while (eptr < md->end_subject)
4235                  {
4236                  int len = 1;
4237                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4238                  rgb = UCD_GRAPHBREAK(c);
4239                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4240                  lgb = rgb;
4241                  eptr += len;
4242                  }
4243              }              }
4244            CHECK_PARTIAL();            CHECK_PARTIAL();
4245            }            }
# Line 4301  for (;;) Line 4307  for (;;)
4307              {              {
4308              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4309    
4310              case 0x000d:              case CHAR_CR:
4311              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4312              break;              break;
4313    
4314              case 0x000a:              case CHAR_LF:
4315              break;              break;
4316    
4317              case 0x000b:              case CHAR_VT:
4318              case 0x000c:              case CHAR_FF:
4319              case 0x0085:              case CHAR_NEL:
4320    #ifndef EBCDIC
4321              case 0x2028:              case 0x2028:
4322              case 0x2029:              case 0x2029:
4323    #endif  /* Not EBCDIC */
4324              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4325              break;              break;
4326              }              }
# Line 4330  for (;;) Line 4338  for (;;)
4338            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4339            switch(c)            switch(c)
4340              {              {
4341                HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
4342              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);  
4343              }              }
4344            }            }
4345          break;          break;
# Line 4366  for (;;) Line 4355  for (;;)
4355            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4356            switch(c)            switch(c)
4357              {              {
4358                HSPACE_CASES: break;  /* Byte and multibyte cases */
4359              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;  
4360              }              }
4361            }            }
4362          break;          break;
# Line 4402  for (;;) Line 4372  for (;;)
4372            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4373            switch(c)            switch(c)
4374              {              {
4375                VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4376              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);  
4377              }              }
4378            }            }
4379          break;          break;
# Line 4426  for (;;) Line 4389  for (;;)
4389            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4390            switch(c)            switch(c)
4391              {              {
4392                VSPACE_CASES: break;
4393              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;  
4394              }              }
4395            }            }
4396          break;          break;
# Line 4592  for (;;) Line 4548  for (;;)
4548              {              {
4549              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4550    
4551              case 0x000d:              case CHAR_CR:
4552              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4553              break;              break;
4554    
4555              case 0x000a:              case CHAR_LF:
4556              break;              break;
4557    
4558              case 0x000b:              case CHAR_VT:
4559              case 0x000c:              case CHAR_FF:
4560              case 0x0085:              case CHAR_NEL:
4561  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4562              case 0x2028:              case 0x2028:
4563              case 0x2029:              case 0x2029:
# Line 4623  for (;;) Line 4579  for (;;)
4579            switch(*eptr++)            switch(*eptr++)
4580              {              {
4581              default: break;              default: break;
4582              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
4583  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4584              case 0x1680:    /* OGHAM SPACE MARK */              HSPACE_MULTIBYTE_CASES:
             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 */  
4585  #endif  #endif
4586              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4587              }              }
# Line 4660  for (;;) Line 4599  for (;;)
4599            switch(*eptr++)            switch(*eptr++)
4600              {              {
4601              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4602              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
4603  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4604              case 0x1680:    /* OGHAM SPACE MARK */              HSPACE_MULTIBYTE_CASES:
             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 */  
4605  #endif  #endif
4606              break;              break;
4607              }              }
# Line 4696  for (;;) Line 4618  for (;;)
4618              }              }
4619            switch(*eptr++)            switch(*eptr++)
4620              {              {
4621              default: break;              VSPACE_BYTE_CASES:
             case 0x0a:      /* LF */  
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
4622  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4623              case 0x2028:    /* LINE SEPARATOR */              VSPACE_MULTIBYTE_CASES:
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4624  #endif  #endif
4625              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4626                default: break;
4627              }              }
4628            }            }
4629          break;          break;
# Line 4722  for (;;) Line 4639  for (;;)
4639            switch(*eptr++)            switch(*eptr++)
4640              {              {
4641              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4642              case 0x0a:      /* LF */              VSPACE_BYTE_CASES:
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
4643  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4644              case 0x2028:    /* LINE SEPARATOR */              VSPACE_MULTIBYTE_CASES:
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4645  #endif  #endif
4646              break;              break;
4647              }              }
# Line 5007  for (;;) Line 4919  for (;;)
4919              }              }
4920            /* Control never gets here */            /* Control never gets here */
4921    
4922            /* This should never occur */            case PT_CLIST:
4923              for (fi = min;; fi++)
4924                {
4925                const pcre_uint32 *cp;
4926                RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);
4927                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4928                if (fi >= max) RRETURN(MATCH_NOMATCH);
4929                if (eptr >= md->end_subject)
4930                  {
4931                  SCHECK_PARTIAL();
4932                  RRETURN(MATCH_NOMATCH);
4933                  }
4934                GETCHARINCTEST(c, eptr);
4935                cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);
4936                for (;;)
4937                  {
4938                  if (c < *cp)
4939                    { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
4940                  if (c == *cp++)
4941                    { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
4942                  }
4943                }
4944              /* Control never gets here */
4945    
4946              /* This should never occur */
4947            default:            default:
4948            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4949            }            }
# Line 5029  for (;;) Line 4964  for (;;)
4964              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4965              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4966              }              }
4967            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4968              {              {
4969              int len = 1;              int lgb, rgb;
4970              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4971              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4972              eptr += len;              while (eptr < md->end_subject)
4973                  {
4974                  int len = 1;
4975                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4976                  rgb = UCD_GRAPHBREAK(c);
4977                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4978                  lgb = rgb;
4979                  eptr += len;
4980                  }
4981              }              }
4982            CHECK_PARTIAL();            CHECK_PARTIAL();
4983            }            }
# Line 5082  for (;;) Line 5023  for (;;)
5023              switch(c)              switch(c)
5024                {                {
5025                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5026                case 0x000d:                case CHAR_CR:
5027                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5028                break;                break;
5029                case 0x000a:  
5030                  case CHAR_LF:
5031                break;                break;
5032    
5033                case 0x000b:                case CHAR_VT:
5034                case 0x000c:                case CHAR_FF:
5035                case 0x0085:                case CHAR_NEL:
5036    #ifndef EBCDIC
5037                case 0x2028:                case 0x2028:
5038                case 0x2029:                case 0x2029:
5039    #endif  /* Not EBCDIC */
5040                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5041                break;                break;
5042                }                }
# Line 5101  for (;;) Line 5045  for (;;)
5045              case OP_NOT_HSPACE:              case OP_NOT_HSPACE:
5046              switch(c)              switch(c)
5047                {                {
5048                  HSPACE_CASES: RRETURN(MATCH_NOMATCH);
5049                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);  
5050                }                }
5051              break;              break;
5052    
5053              case OP_HSPACE:              case OP_HSPACE:
5054              switch(c)              switch(c)
5055                {                {
5056                  HSPACE_CASES: break;
5057                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;  
5058                }                }
5059              break;              break;
5060    
5061              case OP_NOT_VSPACE:              case OP_NOT_VSPACE:
5062              switch(c)              switch(c)
5063                {                {
5064                  VSPACE_CASES: RRETURN(MATCH_NOMATCH);
5065                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);  
5066                }                }
5067              break;              break;
5068    
5069              case OP_VSPACE:              case OP_VSPACE:
5070              switch(c)              switch(c)
5071                {                {
5072                  VSPACE_CASES: break;
5073                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;  
5074                }                }
5075              break;              break;
5076    
# Line 5256  for (;;) Line 5148  for (;;)
5148              switch(c)              switch(c)
5149                {                {
5150                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5151                case 0x000d:                case CHAR_CR:
5152                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5153                break;                break;
5154    
5155                case 0x000a:                case CHAR_LF:
5156                break;                break;
5157    
5158                case 0x000b:                case CHAR_VT:
5159                case 0x000c:                case CHAR_FF:
5160                case 0x0085:                case CHAR_NEL:
5161  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5162                case 0x2028:                case 0x2028:
5163                case 0x2029:                case 0x2029:
# Line 5279  for (;;) Line 5171  for (;;)
5171              switch(c)              switch(c)
5172                {                {
5173                default: break;                default: break;
5174                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
5175  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5176                case 0x1680:    /* OGHAM SPACE MARK */                HSPACE_MULTIBYTE_CASES:
               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 */  
5177  #endif  #endif
5178                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5179                }                }
# Line 5308  for (;;) Line 5183  for (;;)
5183              switch(c)              switch(c)
5184                {                {
5185                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5186                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
5187  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5188                case 0x1680:    /* OGHAM SPACE MARK */                HSPACE_MULTIBYTE_CASES:
               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 */  
5189  #endif  #endif
5190                break;                break;
5191                }                }
# Line 5337  for (;;) Line 5195  for (;;)
5195              switch(c)              switch(c)
5196                {                {
5197                default: break;                default: break;
5198                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
5199  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5200                case 0x2028:    /* LINE SEPARATOR */                VSPACE_MULTIBYTE_CASES:
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5201  #endif  #endif
5202                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5203                }                }
# Line 5354  for (;;) Line 5207  for (;;)
5207              switch(c)              switch(c)
5208                {                {
5209                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5210                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
5211  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5212                case 0x2028:    /* LINE SEPARATOR */                VSPACE_MULTIBYTE_CASES:
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5213  #endif  #endif
5214                break;                break;
5215                }                }
# Line 5564  for (;;) Line 5412  for (;;)
5412              eptr+= len;              eptr+= len;
5413              }              }
5414            break;            break;
5415    
5416              case PT_CLIST:
5417              for (i = min; i < max; i++)
5418                {
5419                const pcre_uint32 *cp;
5420                int len = 1;
5421                if (eptr >= md->end_subject)
5422                  {
5423                  SCHECK_PARTIAL();
5424                  break;
5425                  }
5426                GETCHARLENTEST(c, eptr, len);
5427                cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);
5428                for (;;)
5429                  {
5430                  if (c < *cp)
5431                    { if (prop_fail_result) break; else goto GOT_MAX; }
5432                  if (c == *cp++)
5433                    { if (prop_fail_result) goto GOT_MAX; else break; }
5434                  }
5435                eptr += len;
5436                }
5437              GOT_MAX:
5438              break;
5439    
5440            default:            default:
5441            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
# Line 5588  for (;;) Line 5460  for (;;)
5460          {          {
5461          for (i = min; i < max; i++)          for (i = min; i < max; i++)
5462            {            {
           int len = 1;  
5463            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
5464              {              {
5465              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5466              break;              break;
5467              }              }
5468            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }            else
           if (UCD_CATEGORY(c) == ucp_M) break;  
           eptr += len;  
           while (eptr < md->end_subject)  
5469              {              {
5470              len = 1;              int lgb, rgb;
5471              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
5472              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
5473              eptr += len;              while (eptr < md->end_subject)
5474                  {
5475                  int len = 1;
5476                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5477                  rgb = UCD_GRAPHBREAK(c);
5478                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5479                  lgb = rgb;
5480                  eptr += len;
5481                  }
5482              }              }
5483            CHECK_PARTIAL();            CHECK_PARTIAL();
5484            }            }
# Line 5732  for (;;) Line 5608  for (;;)
5608                break;                break;
5609                }                }
5610              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5611              if (c == 0x000d)              if (c == CHAR_CR)
5612                {                {
5613                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5614                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5615                }                }
5616              else              else
5617                {                {
5618                if (c != 0x000a &&                if (c != CHAR_LF &&
5619                    (md->bsr_anycrlf ||                    (md->bsr_anycrlf ||
5620                     (c != 0x000b && c != 0x000c &&                     (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5621                      c != 0x0085 && c != 0x2028 && c != 0x2029)))  #ifndef EBCDIC
5622                        && c != 0x2028 && c != 0x2029
5623    #endif  /* Not EBCDIC */
5624                        )))
5625                  break;                  break;
5626                eptr += len;                eptr += len;
5627                }                }
# Line 5763  for (;;) Line 5642  for (;;)
5642              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5643              switch(c)              switch(c)
5644                {                {
5645                  HSPACE_CASES: gotspace = TRUE; break;
5646                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;  
5647                }                }
5648              if (gotspace == (ctype == OP_NOT_HSPACE)) break;              if (gotspace == (ctype == OP_NOT_HSPACE)) break;
5649              eptr += len;              eptr += len;
# Line 5805  for (;;) Line 5664  for (;;)
5664              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5665              switch(c)              switch(c)
5666                {                {
5667                  VSPACE_CASES: gotspace = TRUE; break;
5668                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;  
5669                }                }
5670              if (gotspace == (ctype == OP_NOT_VSPACE)) break;              if (gotspace == (ctype == OP_NOT_VSPACE)) break;
5671              eptr += len;              eptr += len;
# Line 5928  for (;;) Line 5779  for (;;)
5779            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5780            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5781            BACKCHAR(eptr);            BACKCHAR(eptr);
5782            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_NL &&
5783                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
5784            }            }
5785          }          }
5786        else        else
# Line 5980  for (;;) Line 5831  for (;;)
5831                break;                break;
5832                }                }
5833              c = *eptr;              c = *eptr;
5834              if (c == 0x000d)              if (c == CHAR_CR)
5835                {                {
5836                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5837                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5838                }                }
5839              else              else
5840                {                {
5841                if (c != 0x000a && (md->bsr_anycrlf ||                if (c != CHAR_LF && (md->bsr_anycrlf ||
5842                  (c != 0x000b && c != 0x000c && c != 0x0085                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5843  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5844                  && c != 0x2028 && c != 0x2029                   && c != 0x2028 && c != 0x2029
5845  #endif  #endif
5846                  ))) break;                   ))) break;
5847                eptr++;                eptr++;
5848                }                }
5849              }              }
# Line 6006  for (;;) Line 5857  for (;;)
5857                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5858                break;                break;
5859                }                }
5860              c = *eptr;              switch(*eptr)
5861              if (c == 0x09 || c == 0x20 || c == 0xa0                {
5862                  default: eptr++; break;
5863                  HSPACE_BYTE_CASES:
5864  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5865                || c == 0x1680 || c == 0x180e || (c >= 0x2000 && c <= 0x200A)                HSPACE_MULTIBYTE_CASES:
               || c == 0x202f || c == 0x205f || c == 0x3000  
5866  #endif  #endif
5867                ) break;                goto ENDLOOP00;
5868              eptr++;                }
5869              }              }
5870              ENDLOOP00:
5871            break;            break;
5872    
5873            case OP_HSPACE:            case OP_HSPACE:
# Line 6025  for (;;) Line 5878  for (;;)
5878                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5879                break;                break;
5880                }                }
5881              c = *eptr;              switch(*eptr)
5882              if (c != 0x09 && c != 0x20 && c != 0xa0                {
5883                  default: goto ENDLOOP01;
5884                  HSPACE_BYTE_CASES:
5885  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5886                && c != 0x1680 && c != 0x180e && (c < 0x2000 || c > 0x200A)                HSPACE_MULTIBYTE_CASES:
               && c != 0x202f && c != 0x205f && c != 0x3000  
5887  #endif  #endif
5888                ) break;                eptr++; break;
5889              eptr++;                }
5890              }              }
5891              ENDLOOP01:
5892            break;            break;
5893    
5894            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
# Line 6044  for (;;) Line 5899  for (;;)
5899                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5900                break;                break;
5901                }                }
5902              c = *eptr;              switch(*eptr)
5903              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85                {
5904                  default: eptr++; break;
5905                  VSPACE_BYTE_CASES:
5906  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5907                || c == 0x2028 || c == 0x2029                VSPACE_MULTIBYTE_CASES:
5908  #endif  #endif
5909                ) break;                goto ENDLOOP02;
5910              eptr++;                }
5911              }              }
5912              ENDLOOP02:
5913            break;            break;
5914    
5915            case OP_VSPACE:            case OP_VSPACE:
# Line 6062  for (;;) Line 5920  for (;;)
5920                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5921                break;                break;
5922                }                }
5923              c = *eptr;              switch(*eptr)
5924              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85                {
5925                  default: goto ENDLOOP03;
5926                  VSPACE_BYTE_CASES:
5927  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5928                && c != 0x2028 && c != 0x2029                VSPACE_MULTIBYTE_CASES:
5929  #endif  #endif
5930                ) break;                eptr++; break;
5931              eptr++;                }
5932              }              }
5933              ENDLOOP03:
5934            break;            break;
5935    
5936            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
# Line 6166  for (;;) Line 6027  for (;;)
6027            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
6028            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
6029            eptr--;            eptr--;
6030            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_LF &&
6031                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
6032            }            }
6033          }          }
6034    

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

  ViewVC Help
Powered by ViewVC 1.1.5