/[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 933 by ph10, Sat Feb 25 12:18:23 2012 UTC revision 1033 by ph10, Mon Sep 10 11:02:48 2012 UTC
# Line 37  POSSIBILITY OF SUCH DAMAGE. Line 37  POSSIBILITY OF SUCH DAMAGE.
37  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
38  */  */
39    
   
40  /* This module contains pcre_exec(), the externally visible function that does  /* This module contains pcre_exec(), the externally visible function that does
41  pattern matching using an NFA algorithm, trying to mimic Perl as closely as  pattern matching using an NFA algorithm, trying to mimic Perl as closely as
42  possible. There are also some static supporting functions. */  possible. There are also some static supporting functions. */
# Line 907  for (;;) Line 906  for (;;)
906        }        }
907      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
908        {        {
       md->match_function_type = MATCH_CBEGROUP;  
909        RMATCH(eptr, prev, offset_top, md, eptrb, RM66);        RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
910        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
911        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
# Line 1036  for (;;) Line 1034  for (;;)
1034    
1035      for (;;)      for (;;)
1036        {        {
1037        if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;        if (op >= OP_SBRA || op == OP_ONCE)
1038            md->match_function_type = MATCH_CBEGROUP;
1039    
1040        /* If this is not a possibly empty group, and there are no (*THEN)s in        /* If this is not a possibly empty group, and there are no (*THEN)s in
1041        the pattern, and this is the final alternative, optimize as described        the pattern, and this is the final alternative, optimize as described
# Line 1575  for (;;) Line 1574  for (;;)
1574          mstart = md->start_match_ptr;   /* In case \K reset it */          mstart = md->start_match_ptr;   /* In case \K reset it */
1575          break;          break;
1576          }          }
1577          md->mark = save_mark;
1578    
1579        /* PCRE does not allow THEN to escape beyond an assertion; it is treated        /* A COMMIT failure must fail the entire assertion, without trying any
1580        as NOMATCH. */        subsequent branches. */
1581    
1582          if (rrc == MATCH_COMMIT) RRETURN(MATCH_NOMATCH);
1583    
1584          /* PCRE does not allow THEN to escape beyond an assertion; it
1585          is treated as NOMATCH. */
1586    
1587        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1588        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
       md->mark = save_mark;  
1589        }        }
1590      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1591    
# Line 1789  for (;;) Line 1793  for (;;)
1793            goto RECURSION_MATCHED;        /* Exit loop; end processing */            goto RECURSION_MATCHED;        /* Exit loop; end processing */
1794            }            }
1795    
1796          /* PCRE does not allow THEN to escape beyond a recursion; it is treated          /* PCRE does not allow THEN or COMMIT to escape beyond a recursion; it
1797          as NOMATCH. */          is treated as NOMATCH. */
1798    
1799          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN &&
1800                     rrc != MATCH_COMMIT)
1801            {            {
1802            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1803            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
# Line 2003  for (;;) Line 2008  for (;;)
2008          }          }
2009        if (*prev >= OP_SBRA)    /* Could match an empty string */        if (*prev >= OP_SBRA)    /* Could match an empty string */
2010          {          {
         md->match_function_type = MATCH_CBEGROUP;  
2011          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
2012          RRETURN(rrc);          RRETURN(rrc);
2013          }          }
# Line 2012  for (;;) Line 2016  for (;;)
2016        }        }
2017      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
2018        {        {
       if (*prev >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;  
2019        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
2020        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
2021        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
# Line 2412  for (;;) Line 2415  for (;;)
2415        {        {
2416        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2417    
2418        case 0x000d:        case CHAR_CR:
2419        if (eptr >= md->end_subject)        if (eptr >= md->end_subject)
2420          {          {
2421          SCHECK_PARTIAL();          SCHECK_PARTIAL();
2422          }          }
2423        else if (*eptr == 0x0a) eptr++;        else if (*eptr == CHAR_LF) eptr++;
2424        break;        break;
2425    
2426        case 0x000a:        case CHAR_LF:
2427        break;        break;
2428    
2429        case 0x000b:        case CHAR_VT:
2430        case 0x000c:        case CHAR_FF:
2431        case 0x0085:        case CHAR_NEL:
2432    #ifndef EBCDIC
2433        case 0x2028:        case 0x2028:
2434        case 0x2029:        case 0x2029:
2435    #endif  /* Not EBCDIC */
2436        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2437        break;        break;
2438        }        }
# Line 2444  for (;;) Line 2449  for (;;)
2449      switch(c)      switch(c)
2450        {        {
2451        default: break;        default: break;
2452        case 0x09:      /* HT */        case CHAR_HT:
2453        case 0x20:      /* SPACE */        case CHAR_SPACE:
2454    #ifndef EBCDIC
2455        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
2456        case 0x1680:    /* OGHAM SPACE MARK */        case 0x1680:    /* OGHAM SPACE MARK */
2457        case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */        case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 2463  for (;;) Line 2469  for (;;)
2469        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2470        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2471        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2472    #endif  /* Not EBCDIC */
2473        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2474        }        }
2475      ecode++;      ecode++;
# Line 2478  for (;;) Line 2485  for (;;)
2485      switch(c)      switch(c)
2486        {        {
2487        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2488        case 0x09:      /* HT */        case CHAR_HT:
2489        case 0x20:      /* SPACE */        case CHAR_SPACE:
2490    #ifndef EBCDIC
2491        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
2492        case 0x1680:    /* OGHAM SPACE MARK */        case 0x1680:    /* OGHAM SPACE MARK */
2493        case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */        case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 2497  for (;;) Line 2505  for (;;)
2505        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2506        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2507        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2508    #endif  /* Not EBCDIC */
2509        break;        break;
2510        }        }
2511      ecode++;      ecode++;
# Line 2512  for (;;) Line 2521  for (;;)
2521      switch(c)      switch(c)
2522        {        {
2523        default: break;        default: break;
2524        case 0x0a:      /* LF */        case CHAR_LF:
2525        case 0x0b:      /* VT */        case CHAR_VT:
2526        case 0x0c:      /* FF */        case CHAR_FF:
2527        case 0x0d:      /* CR */        case CHAR_CR:
2528        case 0x85:      /* NEL */        case CHAR_NEL:
2529    #ifndef EBCDIC
2530        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2531        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2532    #endif  /* Not EBCDIC */
2533        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2534        }        }
2535      ecode++;      ecode++;
# Line 2534  for (;;) Line 2545  for (;;)
2545      switch(c)      switch(c)
2546        {        {
2547        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2548        case 0x0a:      /* LF */        case CHAR_LF:
2549        case 0x0b:      /* VT */        case CHAR_VT:
2550        case 0x0c:      /* FF */        case CHAR_FF:
2551        case 0x0d:      /* CR */        case CHAR_CR:
2552        case 0x85:      /* NEL */        case CHAR_NEL:
2553    #ifndef EBCDIC
2554        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2555        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2556    #endif  /* Not EBCDIC */
2557        break;        break;
2558        }        }
2559      ecode++;      ecode++;
# Line 2638  for (;;) Line 2651  for (;;)
2651        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2652        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2653        }        }
2654      GETCHARINCTEST(c, eptr);      else
2655      if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);        {
2656      while (eptr < md->end_subject)        int lgb, rgb;
2657        {        GETCHARINCTEST(c, eptr);
2658        int len = 1;        lgb = UCD_GRAPHBREAK(c);
2659        if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }        while (eptr < md->end_subject)
2660        if (UCD_CATEGORY(c) != ucp_M) break;          {
2661        eptr += len;          int len = 1;
2662            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2663            rgb = UCD_GRAPHBREAK(c);
2664            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2665            lgb = rgb;
2666            eptr += len;
2667            }
2668        }        }
2669      CHECK_PARTIAL();      CHECK_PARTIAL();
2670      ecode++;      ecode++;
# Line 3425  for (;;) Line 3444  for (;;)
3444      maximizing, find the maximum number of characters and work backwards. */      maximizing, find the maximum number of characters and work backwards. */
3445    
3446      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3447        max, eptr));        max, (char *)eptr));
3448    
3449      if (op >= OP_STARI)  /* Caseless */      if (op >= OP_STARI)  /* Caseless */
3450        {        {
# Line 3694  for (;;) Line 3713  for (;;)
3713      characters and work backwards. */      characters and work backwards. */
3714    
3715      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3716        max, eptr));        max, (char *)eptr));
3717    
3718      if (op >= OP_NOTSTARI)     /* Caseless */      if (op >= OP_NOTSTARI)     /* Caseless */
3719        {        {
# Line 4223  for (;;) Line 4242  for (;;)
4242              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4243              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4244              }              }
4245            GETCHARINCTEST(c, eptr);            else
4246            if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);              {
4247            while (eptr < md->end_subject)              int lgb, rgb;
4248              {              GETCHARINCTEST(c, eptr);
4249              int len = 1;              lgb = UCD_GRAPHBREAK(c);
4250              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }             while (eptr < md->end_subject)
4251              if (UCD_CATEGORY(c) != ucp_M) break;                {
4252              eptr += len;                int len = 1;
4253                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4254                  rgb = UCD_GRAPHBREAK(c);
4255                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4256                  lgb = rgb;
4257                  eptr += len;
4258                  }
4259              }              }
4260            CHECK_PARTIAL();            CHECK_PARTIAL();
4261            }            }
# Line 4298  for (;;) Line 4323  for (;;)
4323              {              {
4324              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4325    
4326              case 0x000d:              case CHAR_CR:
4327              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4328              break;              break;
4329    
4330              case 0x000a:              case CHAR_LF:
4331              break;              break;
4332    
4333              case 0x000b:              case CHAR_VT:
4334              case 0x000c:              case CHAR_FF:
4335              case 0x0085:              case CHAR_NEL:
4336    #ifndef EBCDIC
4337              case 0x2028:              case 0x2028:
4338              case 0x2029:              case 0x2029:
4339    #endif  /* Not EBCDIC */
4340              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4341              break;              break;
4342              }              }
# Line 4328  for (;;) Line 4355  for (;;)
4355            switch(c)            switch(c)
4356              {              {
4357              default: break;              default: break;
4358              case 0x09:      /* HT */              case CHAR_HT:
4359              case 0x20:      /* SPACE */              case CHAR_SPACE:
4360    #ifndef EBCDIC
4361              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4362              case 0x1680:    /* OGHAM SPACE MARK */              case 0x1680:    /* OGHAM SPACE MARK */
4363              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 4347  for (;;) Line 4375  for (;;)
4375              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
4376              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4377              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
4378    #endif  /* Not EBCDIC */
4379              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4380              }              }
4381            }            }
# Line 4364  for (;;) Line 4393  for (;;)
4393            switch(c)            switch(c)
4394              {              {
4395              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4396              case 0x09:      /* HT */              case CHAR_HT:
4397              case 0x20:      /* SPACE */              case CHAR_SPACE:
4398    #ifndef EBCDIC
4399              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4400              case 0x1680:    /* OGHAM SPACE MARK */              case 0x1680:    /* OGHAM SPACE MARK */
4401              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 4383  for (;;) Line 4413  for (;;)
4413              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
4414              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4415              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
4416    #endif
4417              break;              break;
4418              }              }
4419            }            }
# Line 4400  for (;;) Line 4431  for (;;)
4431            switch(c)            switch(c)
4432              {              {
4433              default: break;              default: break;
4434              case 0x0a:      /* LF */              case CHAR_LF:
4435              case 0x0b:      /* VT */              case CHAR_VT:
4436              case 0x0c:      /* FF */              case CHAR_FF:
4437              case 0x0d:      /* CR */              case CHAR_CR:
4438              case 0x85:      /* NEL */              case CHAR_NEL:
4439    #ifndef EBCDIC
4440              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
4441              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
4442    #endif
4443              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4444              }              }
4445            }            }
# Line 4424  for (;;) Line 4457  for (;;)
4457            switch(c)            switch(c)
4458              {              {
4459              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4460              case 0x0a:      /* LF */              case CHAR_LF:
4461              case 0x0b:      /* VT */              case CHAR_VT:
4462              case 0x0c:      /* FF */              case CHAR_FF:
4463              case 0x0d:      /* CR */              case CHAR_CR:
4464              case 0x85:      /* NEL */              case CHAR_NEL:
4465    #ifndef EBCDIC
4466              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
4467              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
4468    #endif
4469              break;              break;
4470              }              }
4471            }            }
# Line 4589  for (;;) Line 4624  for (;;)
4624              {              {
4625              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4626    
4627              case 0x000d:              case CHAR_CR:
4628              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4629              break;              break;
4630    
4631              case 0x000a:              case CHAR_LF:
4632              break;              break;
4633    
4634              case 0x000b:              case CHAR_VT:
4635              case 0x000c:              case CHAR_FF:
4636              case 0x0085:              case CHAR_NEL:
4637  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4638              case 0x2028:              case 0x2028:
4639              case 0x2029:              case 0x2029:
# Line 4620  for (;;) Line 4655  for (;;)
4655            switch(*eptr++)            switch(*eptr++)
4656              {              {
4657              default: break;              default: break;
4658              case 0x09:      /* HT */              case CHAR_HT:
4659              case 0x20:      /* SPACE */              case CHAR_SPACE:
4660    #ifndef EBCDIC
4661              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4662  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4663              case 0x1680:    /* OGHAM SPACE MARK */              case 0x1680:    /* OGHAM SPACE MARK */
# Line 4640  for (;;) Line 4676  for (;;)
4676              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
4677              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4678              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
4679  #endif  #endif  /* COMPILE_PCRE16 */
4680    #endif  /* Not EBCDIC */
4681              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4682              }              }
4683            }            }
# Line 4657  for (;;) Line 4694  for (;;)
4694            switch(*eptr++)            switch(*eptr++)
4695              {              {
4696              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4697              case 0x09:      /* HT */              case CHAR_HT:
4698              case 0x20:      /* SPACE */              case CHAR_SPACE:
4699    #ifndef EBCDIC
4700              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4701  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4702              case 0x1680:    /* OGHAM SPACE MARK */              case 0x1680:    /* OGHAM SPACE MARK */
# Line 4677  for (;;) Line 4715  for (;;)
4715              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
4716              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4717              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
4718  #endif  #endif  /* COMPILE_PCRE16 */
4719    #endif  /* Not EBCDIC */
4720              break;              break;
4721              }              }
4722            }            }
# Line 4694  for (;;) Line 4733  for (;;)
4733            switch(*eptr++)            switch(*eptr++)
4734              {              {
4735              default: break;              default: break;
4736              case 0x0a:      /* LF */              case CHAR_LF:
4737              case 0x0b:      /* VT */              case CHAR_VT:
4738              case 0x0c:      /* FF */              case CHAR_FF:
4739              case 0x0d:      /* CR */              case CHAR_CR:
4740              case 0x85:      /* NEL */              case CHAR_NEL:
4741  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4742              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
4743              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
# Line 4719  for (;;) Line 4758  for (;;)
4758            switch(*eptr++)            switch(*eptr++)
4759              {              {
4760              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4761              case 0x0a:      /* LF */              case CHAR_LF:
4762              case 0x0b:      /* VT */              case CHAR_VT:
4763              case 0x0c:      /* FF */              case CHAR_FF:
4764              case 0x0d:      /* CR */              case CHAR_CR:
4765              case 0x85:      /* NEL */              case CHAR_NEL:
4766  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4767              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
4768              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
# Line 5026  for (;;) Line 5065  for (;;)
5065              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5066              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
5067              }              }
5068            GETCHARINCTEST(c, eptr);            else
5069            if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);              {
5070            while (eptr < md->end_subject)              int lgb, rgb;
5071              {              GETCHARINCTEST(c, eptr);
5072              int len = 1;              lgb = UCD_GRAPHBREAK(c);
5073              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              while (eptr < md->end_subject)
5074              if (UCD_CATEGORY(c) != ucp_M) break;                {
5075              eptr += len;                int len = 1;
5076                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5077                  rgb = UCD_GRAPHBREAK(c);
5078                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5079                  lgb = rgb;
5080                  eptr += len;
5081                  }
5082              }              }
5083            CHECK_PARTIAL();            CHECK_PARTIAL();
5084            }            }
# Line 5079  for (;;) Line 5124  for (;;)
5124              switch(c)              switch(c)
5125                {                {
5126                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5127                case 0x000d:                case CHAR_CR:
5128                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5129                break;                break;
5130                case 0x000a:  
5131                  case CHAR_LF:
5132                break;                break;
5133    
5134                case 0x000b:                case CHAR_VT:
5135                case 0x000c:                case CHAR_FF:
5136                case 0x0085:                case CHAR_NEL:
5137    #ifndef EBCDIC
5138                case 0x2028:                case 0x2028:
5139                case 0x2029:                case 0x2029:
5140    #endif  /* Not EBCDIC */
5141                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5142                break;                break;
5143                }                }
# Line 5099  for (;;) Line 5147  for (;;)
5147              switch(c)              switch(c)
5148                {                {
5149                default: break;                default: break;
5150                case 0x09:      /* HT */                case CHAR_HT:
5151                case 0x20:      /* SPACE */                case CHAR_SPACE:
5152    #ifndef EBCDIC
5153                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
5154                case 0x1680:    /* OGHAM SPACE MARK */                case 0x1680:    /* OGHAM SPACE MARK */
5155                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 5118  for (;;) Line 5167  for (;;)
5167                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
5168                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5169                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
5170    #endif  /* Not EBCDIC */
5171                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5172                }                }
5173              break;              break;
# Line 5126  for (;;) Line 5176  for (;;)
5176              switch(c)              switch(c)
5177                {                {
5178                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5179                case 0x09:      /* HT */                case CHAR_HT:
5180                case 0x20:      /* SPACE */                case CHAR_SPACE:
5181    #ifndef EBCDIC
5182                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
5183                case 0x1680:    /* OGHAM SPACE MARK */                case 0x1680:    /* OGHAM SPACE MARK */
5184                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 5145  for (;;) Line 5196  for (;;)
5196                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
5197                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5198                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
5199    #endif  /* Not EBCDIC */
5200                break;                break;
5201                }                }
5202              break;              break;
# Line 5153  for (;;) Line 5205  for (;;)
5205              switch(c)              switch(c)
5206                {                {
5207                default: break;                default: break;
5208                case 0x0a:      /* LF */                case CHAR_LF:
5209                case 0x0b:      /* VT */                case CHAR_VT:
5210                case 0x0c:      /* FF */                case CHAR_FF:
5211                case 0x0d:      /* CR */                case CHAR_CR:
5212                case 0x85:      /* NEL */                case CHAR_NEL:
5213    #ifndef EBCDIC
5214                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
5215                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
5216    #endif  /* Not EBCDIC */
5217                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5218                }                }
5219              break;              break;
# Line 5168  for (;;) Line 5222  for (;;)
5222              switch(c)              switch(c)
5223                {                {
5224                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5225                case 0x0a:      /* LF */                case CHAR_LF:
5226                case 0x0b:      /* VT */                case CHAR_VT:
5227                case 0x0c:      /* FF */                case CHAR_FF:
5228                case 0x0d:      /* CR */                case CHAR_CR:
5229                case 0x85:      /* NEL */                case CHAR_NEL:
5230    #ifndef EBCDIC
5231                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
5232                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
5233    #endif  /* Not EBCDIC */
5234                break;                break;
5235                }                }
5236              break;              break;
# Line 5253  for (;;) Line 5309  for (;;)
5309              switch(c)              switch(c)
5310                {                {
5311                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5312                case 0x000d:                case CHAR_CR:
5313                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5314                break;                break;
5315    
5316                case 0x000a:                case CHAR_LF:
5317                break;                break;
5318    
5319                case 0x000b:                case CHAR_VT:
5320                case 0x000c:                case CHAR_FF:
5321                case 0x0085:                case CHAR_NEL:
5322  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5323                case 0x2028:                case 0x2028:
5324                case 0x2029:                case 0x2029:
# Line 5276  for (;;) Line 5332  for (;;)
5332              switch(c)              switch(c)
5333                {                {
5334                default: break;                default: break;
5335                case 0x09:      /* HT */                case CHAR_HT:
5336                case 0x20:      /* SPACE */                case CHAR_SPACE:
5337    #ifndef EBCDIC
5338                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
5339  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5340                case 0x1680:    /* OGHAM SPACE MARK */                case 0x1680:    /* OGHAM SPACE MARK */
# Line 5296  for (;;) Line 5353  for (;;)
5353                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
5354                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5355                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
5356  #endif  #endif  /* COMPILE_PCRE16 */
5357    #endif  /* Not EBCDIC */
5358                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5359                }                }
5360              break;              break;
# Line 5305  for (;;) Line 5363  for (;;)
5363              switch(c)              switch(c)
5364                {                {
5365                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5366                case 0x09:      /* HT */                case CHAR_HT:
5367                case 0x20:      /* SPACE */                case CHAR_SPACE:
5368    #ifndef EBCDIC
5369                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
5370  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5371                case 0x1680:    /* OGHAM SPACE MARK */                case 0x1680:    /* OGHAM SPACE MARK */
# Line 5325  for (;;) Line 5384  for (;;)
5384                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
5385                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5386                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
5387  #endif  #endif  /* COMPILE_PCRE16 */
5388    #endif  /* Not EBCDIC */
5389                break;                break;
5390                }                }
5391              break;              break;
# Line 5334  for (;;) Line 5394  for (;;)
5394              switch(c)              switch(c)
5395                {                {
5396                default: break;                default: break;
5397                case 0x0a:      /* LF */                case CHAR_LF:
5398                case 0x0b:      /* VT */                case CHAR_VT:
5399                case 0x0c:      /* FF */                case CHAR_FF:
5400                case 0x0d:      /* CR */                case CHAR_CR:
5401                case 0x85:      /* NEL */                case CHAR_NEL:
5402  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5403                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
5404                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
# Line 5351  for (;;) Line 5411  for (;;)
5411              switch(c)              switch(c)
5412                {                {
5413                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5414                case 0x0a:      /* LF */                case CHAR_LF:
5415                case 0x0b:      /* VT */                case CHAR_VT:
5416                case 0x0c:      /* FF */                case CHAR_FF:
5417                case 0x0d:      /* CR */                case CHAR_CR:
5418                case 0x85:      /* NEL */                case CHAR_NEL:
5419  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5420                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
5421                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
# Line 5585  for (;;) Line 5645  for (;;)
5645          {          {
5646          for (i = min; i < max; i++)          for (i = min; i < max; i++)
5647            {            {
           int len = 1;  
5648            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
5649              {              {
5650              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5651              break;              break;
5652              }              }
5653            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }            else
5654            if (UCD_CATEGORY(c) == ucp_M) break;              {
5655            eptr += len;              int lgb, rgb;
5656            while (eptr < md->end_subject)              GETCHARINCTEST(c, eptr);
5657              {              lgb = UCD_GRAPHBREAK(c);
5658              len = 1;              while (eptr < md->end_subject)
5659              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }                {
5660              if (UCD_CATEGORY(c) != ucp_M) break;                int len = 1;
5661              eptr += len;                if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5662                  rgb = UCD_GRAPHBREAK(c);
5663                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5664                  lgb = rgb;
5665                  eptr += len;
5666                  }
5667              }              }
5668            CHECK_PARTIAL();            CHECK_PARTIAL();
5669            }            }
# Line 5729  for (;;) Line 5793  for (;;)
5793                break;                break;
5794                }                }
5795              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5796              if (c == 0x000d)              if (c == CHAR_CR)
5797                {                {
5798                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5799                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5800                }                }
5801              else              else
5802                {                {
5803                if (c != 0x000a &&                if (c != CHAR_LF &&
5804                    (md->bsr_anycrlf ||                    (md->bsr_anycrlf ||
5805                     (c != 0x000b && c != 0x000c &&                     (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5806                      c != 0x0085 && c != 0x2028 && c != 0x2029)))  #ifndef EBCDIC
5807                        && c != 0x2028 && c != 0x2029
5808    #endif  /* Not EBCDIC */
5809                        )))
5810                  break;                  break;
5811                eptr += len;                eptr += len;
5812                }                }
# Line 5761  for (;;) Line 5828  for (;;)
5828              switch(c)              switch(c)
5829                {                {
5830                default: gotspace = FALSE; break;                default: gotspace = FALSE; break;
5831                case 0x09:      /* HT */                case CHAR_HT:
5832                case 0x20:      /* SPACE */                case CHAR_SPACE:
5833    #ifndef EBCDIC
5834                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
5835                case 0x1680:    /* OGHAM SPACE MARK */                case 0x1680:    /* OGHAM SPACE MARK */
5836                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 5780  for (;;) Line 5848  for (;;)
5848                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
5849                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5850                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
5851    #endif  /* Not EBCDIC */
5852                gotspace = TRUE;                gotspace = TRUE;
5853                break;                break;
5854                }                }
# Line 5803  for (;;) Line 5872  for (;;)
5872              switch(c)              switch(c)
5873                {                {
5874                default: gotspace = FALSE; break;                default: gotspace = FALSE; break;
5875                case 0x0a:      /* LF */                case CHAR_LF:
5876                case 0x0b:      /* VT */                case CHAR_VT:
5877                case 0x0c:      /* FF */                case CHAR_FF:
5878                case 0x0d:      /* CR */                case CHAR_CR:
5879                case 0x85:      /* NEL */                case CHAR_NEL:
5880    #ifndef EBCDIC
5881                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
5882                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
5883    #endif  /* Not EBCDIC */
5884                gotspace = TRUE;                gotspace = TRUE;
5885                break;                break;
5886                }                }
# Line 5925  for (;;) Line 5996  for (;;)
5996            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5997            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5998            BACKCHAR(eptr);            BACKCHAR(eptr);
5999            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_NL &&
6000                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
6001            }            }
6002          }          }
6003        else        else
# Line 5977  for (;;) Line 6048  for (;;)
6048                break;                break;
6049                }                }
6050              c = *eptr;              c = *eptr;
6051              if (c == 0x000d)              if (c == CHAR_CR)
6052                {                {
6053                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
6054                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
6055                }                }
6056              else              else
6057                {                {
6058                if (c != 0x000a && (md->bsr_anycrlf ||                if (c != CHAR_LF && (md->bsr_anycrlf ||
6059                  (c != 0x000b && c != 0x000c && c != 0x0085                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
6060  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
6061                  && c != 0x2028 && c != 0x2029                   && c != 0x2028 && c != 0x2029
6062  #endif  #endif
6063                  ))) break;                   ))) break;
6064                eptr++;                eptr++;
6065                }                }
6066              }              }
# Line 6004  for (;;) Line 6075  for (;;)
6075                break;                break;
6076                }                }
6077              c = *eptr;              c = *eptr;
6078              if (c == 0x09 || c == 0x20 || c == 0xa0              if (c == CHAR_HT || c == CHAR_SPACE
6079    #ifndef EBCDIC
6080                  || c == 0xa0
6081  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
6082                || c == 0x1680 || c == 0x180e || (c >= 0x2000 && c <= 0x200A)                || c == 0x1680 || c == 0x180e || (c >= 0x2000 && c <= 0x200A)
6083                || c == 0x202f || c == 0x205f || c == 0x3000                || c == 0x202f || c == 0x205f || c == 0x3000
6084  #endif  #endif  /* COMPILE_PCRE16 */
6085    #endif  /* Not EBCDIC */
6086                ) break;                ) break;
6087              eptr++;              eptr++;
6088              }              }
# Line 6023  for (;;) Line 6097  for (;;)
6097                break;                break;
6098                }                }
6099              c = *eptr;              c = *eptr;
6100              if (c != 0x09 && c != 0x20 && c != 0xa0              if (c != CHAR_HT && c != CHAR_SPACE
6101    #ifndef EBCDIC
6102                  && c != 0xa0
6103  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
6104                && c != 0x1680 && c != 0x180e && (c < 0x2000 || c > 0x200A)                && c != 0x1680 && c != 0x180e && (c < 0x2000 || c > 0x200A)
6105                && c != 0x202f && c != 0x205f && c != 0x3000                && c != 0x202f && c != 0x205f && c != 0x3000
6106  #endif  #endif  /* COMPILE_PCRE16 */
6107    #endif  /* Not EBCDIC */
6108                ) break;                ) break;
6109              eptr++;              eptr++;
6110              }              }
# Line 6042  for (;;) Line 6119  for (;;)
6119                break;                break;
6120                }                }
6121              c = *eptr;              c = *eptr;
6122              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85              if (c == CHAR_LF || c == CHAR_VT || c == CHAR_FF ||
6123                    c == CHAR_CR || c == CHAR_NEL
6124  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
6125                || c == 0x2028 || c == 0x2029                || c == 0x2028 || c == 0x2029
6126  #endif  #endif
# Line 6060  for (;;) Line 6138  for (;;)
6138                break;                break;
6139                }                }
6140              c = *eptr;              c = *eptr;
6141              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85              if (c != CHAR_LF && c != CHAR_VT && c != CHAR_FF &&
6142                    c != CHAR_CR && c != CHAR_NEL
6143  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
6144                && c != 0x2028 && c != 0x2029                && c != 0x2028 && c != 0x2029
6145  #endif  #endif
# Line 6163  for (;;) Line 6242  for (;;)
6242            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
6243            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
6244            eptr--;            eptr--;
6245            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_LF &&
6246                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
6247            }            }
6248          }          }
6249    
# Line 6463  if (extra_data != NULL Line 6542  if (extra_data != NULL
6542                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |
6543                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)
6544    {    {
6545    rc = PRIV(jit_exec)(re, extra_data->executable_jit,    rc = PRIV(jit_exec)(re, extra_data, (const pcre_uchar *)subject, length,
6546      (const pcre_uchar *)subject, length, start_offset, options,         start_offset, options, offsets, offsetcount);
     ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)  
     ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount,  
     ((extra_data->flags & PCRE_EXTRA_MARK) != 0) ? extra_data->mark : NULL);  
6547    
6548    /* PCRE_ERROR_NULL means that the selected normal or partial matching    /* PCRE_ERROR_NULL means that the selected normal or partial matching
6549    mode is not compiled. In this case we simply fallback to interpreter. */    mode is not compiled. In this case we simply fallback to interpreter. */
# Line 7067  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 7143  if (rc == MATCH_MATCH || rc == MATCH_ACC
7143      {      {
7144      register int *iptr, *iend;      register int *iptr, *iend;
7145      int resetcount = 2 + re->top_bracket * 2;      int resetcount = 2 + re->top_bracket * 2;
7146      if (resetcount > offsetcount) resetcount = ocount;      if (resetcount > offsetcount) resetcount = offsetcount;
7147      iptr = offsets + md->end_offset_top;      iptr = offsets + md->end_offset_top;
7148      iend = offsets + resetcount;      iend = offsets + resetcount;
7149      while (iptr < iend) *iptr++ = -1;      while (iptr < iend) *iptr++ = -1;

Legend:
Removed from v.933  
changed lines
  Added in v.1033

  ViewVC Help
Powered by ViewVC 1.1.5