/[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 924 by zherczeg, Wed Feb 22 10:23:56 2012 UTC revision 1047 by zherczeg, Fri Sep 28 15:06:38 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 142  Arguments: Line 141  Arguments:
141    
142  Returns:      >= 0 the number of subject bytes matched  Returns:      >= 0 the number of subject bytes matched
143                -1 no match                -1 no match
144                -2 partial match; always given if at end subject                -2 partial match; always given if at end subject
145  */  */
146    
147  static int  static int
# Line 165  pchars(p, length, FALSE, md); Line 164  pchars(p, length, FALSE, md);
164  printf("\n");  printf("\n");
165  #endif  #endif
166    
167  /* Always fail if reference not set (and not JavaScript compatible - in that  /* Always fail if reference not set (and not JavaScript compatible - in that
168  case the length is passed as zero). */  case the length is passed as zero). */
169    
170  if (length < 0) return -1;  if (length < 0) return -1;
# Line 181  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 220  are in UTF-8 mode. */ Line 230  are in UTF-8 mode. */
230    
231  else  else
232    {    {
233    while (length-- > 0)    while (length-- > 0)
234      {      {
235      if (eptr >= md->end_subject) return -2;   /* Partial match */      if (eptr >= md->end_subject) return -2;   /* Partial match */
236      if (*p++ != *eptr++) return -1;      if (*p++ != *eptr++) return -1;
237      }      }
238    }    }
239    
240  return (int)(eptr - eptr_start);  return (int)(eptr - eptr_start);
# Line 317  argument of match(), which never changes Line 327  argument of match(), which never changes
327    
328  #define RMATCH(ra,rb,rc,rd,re,rw)\  #define RMATCH(ra,rb,rc,rd,re,rw)\
329    {\    {\
330    heapframe *newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\    heapframe *newframe = frame->Xnextframe;\
331    if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\    if (newframe == NULL)\
332    frame->Xwhere = rw; \      {\
333        newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
334        if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
335        newframe->Xnextframe = NULL;\
336        frame->Xnextframe = newframe;\
337        }\
338      frame->Xwhere = rw;\
339    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
340    newframe->Xecode = rb;\    newframe->Xecode = rb;\
341    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
# Line 338  argument of match(), which never changes Line 354  argument of match(), which never changes
354    {\    {\
355    heapframe *oldframe = frame;\    heapframe *oldframe = frame;\
356    frame = oldframe->Xprevframe;\    frame = oldframe->Xprevframe;\
   if (oldframe != &frame_zero) (PUBL(stack_free))(oldframe);\  
357    if (frame != NULL)\    if (frame != NULL)\
358      {\      {\
359      rrc = ra;\      rrc = ra;\
# Line 352  argument of match(), which never changes Line 367  argument of match(), which never changes
367    
368  typedef struct heapframe {  typedef struct heapframe {
369    struct heapframe *Xprevframe;    struct heapframe *Xprevframe;
370      struct heapframe *Xnextframe;
371    
372    /* Function arguments that may change */    /* Function arguments that may change */
373    
# Line 498  the top-level on the stack rather than m Line 514  the top-level on the stack rather than m
514  boost in many cases where there is not much "recursion". */  boost in many cases where there is not much "recursion". */
515    
516  #ifdef NO_RECURSE  #ifdef NO_RECURSE
517  heapframe frame_zero;  heapframe *frame = (heapframe *)md->match_frames_base;
 heapframe *frame = &frame_zero;  
 frame->Xprevframe = NULL;            /* Marks the top level */  
518    
519  /* Copy in the original argument variables */  /* Copy in the original argument variables */
520    
# Line 903  for (;;) Line 917  for (;;)
917        }        }
918      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
919        {        {
       md->match_function_type = MATCH_CBEGROUP;  
920        RMATCH(eptr, prev, offset_top, md, eptrb, RM66);        RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
921        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
922        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
# Line 1032  for (;;) Line 1045  for (;;)
1045    
1046      for (;;)      for (;;)
1047        {        {
1048        if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;        if (op >= OP_SBRA || op == OP_ONCE)
1049            md->match_function_type = MATCH_CBEGROUP;
1050    
1051        /* 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
1052        the pattern, and this is the final alternative, optimize as described        the pattern, and this is the final alternative, optimize as described
# Line 1571  for (;;) Line 1585  for (;;)
1585          mstart = md->start_match_ptr;   /* In case \K reset it */          mstart = md->start_match_ptr;   /* In case \K reset it */
1586          break;          break;
1587          }          }
1588          md->mark = save_mark;
1589    
1590        /* PCRE does not allow THEN to escape beyond an assertion; it is treated        /* A COMMIT failure must fail the entire assertion, without trying any
1591        as NOMATCH. */        subsequent branches. */
1592    
1593          if (rrc == MATCH_COMMIT) RRETURN(MATCH_NOMATCH);
1594    
1595          /* PCRE does not allow THEN to escape beyond an assertion; it
1596          is treated as NOMATCH. */
1597    
1598        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1599        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
       md->mark = save_mark;  
1600        }        }
1601      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1602    
# Line 1785  for (;;) Line 1804  for (;;)
1804            goto RECURSION_MATCHED;        /* Exit loop; end processing */            goto RECURSION_MATCHED;        /* Exit loop; end processing */
1805            }            }
1806    
1807          /* 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
1808          as NOMATCH. */          is treated as NOMATCH. */
1809    
1810          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN &&
1811                     rrc != MATCH_COMMIT)
1812            {            {
1813            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1814            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
# Line 1999  for (;;) Line 2019  for (;;)
2019          }          }
2020        if (*prev >= OP_SBRA)    /* Could match an empty string */        if (*prev >= OP_SBRA)    /* Could match an empty string */
2021          {          {
         md->match_function_type = MATCH_CBEGROUP;  
2022          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
2023          RRETURN(rrc);          RRETURN(rrc);
2024          }          }
# Line 2008  for (;;) Line 2027  for (;;)
2027        }        }
2028      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
2029        {        {
       if (*prev >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;  
2030        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
2031        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
2032        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
# Line 2065  for (;;) Line 2083  for (;;)
2083    
2084      case OP_DOLLM:      case OP_DOLLM:
2085      if (eptr < md->end_subject)      if (eptr < md->end_subject)
2086        {        {
2087        if (!IS_NEWLINE(eptr))        if (!IS_NEWLINE(eptr))
2088          {          {
2089          if (md->partial != 0 &&          if (md->partial != 0 &&
2090              eptr + 1 >= md->end_subject &&              eptr + 1 >= md->end_subject &&
2091              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
2092              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
2093              *eptr == NLBLOCK->nl[0])              *eptr == NLBLOCK->nl[0])
2094            {            {
2095            md->hitend = TRUE;            md->hitend = TRUE;
2096            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2097            }            }
2098          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2099          }          }
2100        }        }
2101      else      else
2102        {        {
# Line 2115  for (;;) Line 2133  for (;;)
2133        if (md->partial != 0 &&        if (md->partial != 0 &&
2134            eptr + 1 >= md->end_subject &&            eptr + 1 >= md->end_subject &&
2135            NLBLOCK->nltype == NLTYPE_FIXED &&            NLBLOCK->nltype == NLTYPE_FIXED &&
2136            NLBLOCK->nllen == 2 &&            NLBLOCK->nllen == 2 &&
2137            *eptr == NLBLOCK->nl[0])            *eptr == NLBLOCK->nl[0])
2138          {          {
2139          md->hitend = TRUE;          md->hitend = TRUE;
2140          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2141          }          }
2142        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2143        }        }
2144    
2145      /* Either at end of string or \n before end. */      /* Either at end of string or \n before end. */
2146    
# Line 2258  for (;;) Line 2276  for (;;)
2276      if (md->partial != 0 &&      if (md->partial != 0 &&
2277          eptr + 1 >= md->end_subject &&          eptr + 1 >= md->end_subject &&
2278          NLBLOCK->nltype == NLTYPE_FIXED &&          NLBLOCK->nltype == NLTYPE_FIXED &&
2279          NLBLOCK->nllen == 2 &&          NLBLOCK->nllen == 2 &&
2280          *eptr == NLBLOCK->nl[0])          *eptr == NLBLOCK->nl[0])
2281        {        {
2282        md->hitend = TRUE;        md->hitend = TRUE;
2283        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2284        }        }
2285    
2286      /* Fall through */      /* Fall through */
2287    
2288      /* Match any single character whatsoever. */      /* Match any single character whatsoever. */
2289    
2290      case OP_ALLANY:      case OP_ALLANY:
2291      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
2292        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
# Line 2408  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 2439  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 2473  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 2507  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 2529  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 2555  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 2615  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 2634  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 2709  for (;;) Line 2695  for (;;)
2695        default:               /* No repeat follows */        default:               /* No repeat follows */
2696        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2697          {          {
2698          if (length == -2) eptr = md->end_subject;   /* Partial match */          if (length == -2) eptr = md->end_subject;   /* Partial match */
2699          CHECK_PARTIAL();          CHECK_PARTIAL();
2700          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2701          }          }
# Line 2735  for (;;) Line 2721  for (;;)
2721        int slength;        int slength;
2722        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2723          {          {
2724          if (slength == -2) eptr = md->end_subject;   /* Partial match */          if (slength == -2) eptr = md->end_subject;   /* Partial match */
2725          CHECK_PARTIAL();          CHECK_PARTIAL();
2726          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2727          }          }
# Line 2759  for (;;) Line 2745  for (;;)
2745          if (fi >= max) RRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2746          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2747            {            {
2748            if (slength == -2) eptr = md->end_subject;   /* Partial match */            if (slength == -2) eptr = md->end_subject;   /* Partial match */
2749            CHECK_PARTIAL();            CHECK_PARTIAL();
2750            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2751            }            }
# Line 2778  for (;;) Line 2764  for (;;)
2764          int slength;          int slength;
2765          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2766            {            {
2767            /* Can't use CHECK_PARTIAL because we don't want to update eptr in            /* Can't use CHECK_PARTIAL because we don't want to update eptr in
2768            the soft partial matching case. */            the soft partial matching case. */
2769    
2770            if (slength == -2 && md->partial != 0 &&            if (slength == -2 && md->partial != 0 &&
2771                md->end_subject > md->start_used_ptr)                md->end_subject > md->start_used_ptr)
2772              {              {
2773              md->hitend = TRUE;              md->hitend = TRUE;
2774              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2775              }              }
# Line 2791  for (;;) Line 2777  for (;;)
2777            }            }
2778          eptr += slength;          eptr += slength;
2779          }          }
2780    
2781        while (eptr >= pp)        while (eptr >= pp)
2782          {          {
2783          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
# Line 3421  for (;;) Line 3407  for (;;)
3407      maximizing, find the maximum number of characters and work backwards. */      maximizing, find the maximum number of characters and work backwards. */
3408    
3409      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3410        max, eptr));        max, (char *)eptr));
3411    
3412      if (op >= OP_STARI)  /* Caseless */      if (op >= OP_STARI)  /* Caseless */
3413        {        {
# Line 3690  for (;;) Line 3676  for (;;)
3676      characters and work backwards. */      characters and work backwards. */
3677    
3678      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,
3679        max, eptr));        max, (char *)eptr));
3680    
3681      if (op >= OP_NOTSTARI)     /* Caseless */      if (op >= OP_NOTSTARI)     /* Caseless */
3682        {        {
# Line 4199  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 4219  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            }            }
4246          }          }
4247    
# Line 4252  for (;;) Line 4265  for (;;)
4265            if (md->partial != 0 &&            if (md->partial != 0 &&
4266                eptr + 1 >= md->end_subject &&                eptr + 1 >= md->end_subject &&
4267                NLBLOCK->nltype == NLTYPE_FIXED &&                NLBLOCK->nltype == NLTYPE_FIXED &&
4268                NLBLOCK->nllen == 2 &&                NLBLOCK->nllen == 2 &&
4269                *eptr == NLBLOCK->nl[0])                *eptr == NLBLOCK->nl[0])
4270              {              {
4271              md->hitend = TRUE;              md->hitend = TRUE;
4272              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4273              }              }
# Line 4294  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 4323  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 4359  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 4395  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 4419  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 4545  for (;;) Line 4508  for (;;)
4508            if (md->partial != 0 &&            if (md->partial != 0 &&
4509                eptr + 1 >= md->end_subject &&                eptr + 1 >= md->end_subject &&
4510                NLBLOCK->nltype == NLTYPE_FIXED &&                NLBLOCK->nltype == NLTYPE_FIXED &&
4511                NLBLOCK->nllen == 2 &&                NLBLOCK->nllen == 2 &&
4512                *eptr == NLBLOCK->nl[0])                *eptr == NLBLOCK->nl[0])
4513              {              {
4514              md->hitend = TRUE;              md->hitend = TRUE;
4515              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4516              }              }
# Line 4585  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 4616  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 4653  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 4689  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 4715  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 5000  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 5022  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            }            }
4984          }          }
4985        else        else
# Line 5059  for (;;) Line 5007  for (;;)
5007              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
5008                  eptr >= md->end_subject &&                  eptr >= md->end_subject &&
5009                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
5010                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
5011                  c == NLBLOCK->nl[0])                  c == NLBLOCK->nl[0])
5012                {                {
5013                md->hitend = TRUE;                md->hitend = TRUE;
5014                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5015                }                }
5016              break;              break;
5017    
5018              case OP_ALLANY:              case OP_ALLANY:
5019              case OP_ANYBYTE:              case OP_ANYBYTE:
5020              break;              break;
# Line 5075  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 5094  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 5233  for (;;) Line 5132  for (;;)
5132              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
5133                  eptr >= md->end_subject &&                  eptr >= md->end_subject &&
5134                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
5135                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
5136                  c == NLBLOCK->nl[0])                  c == NLBLOCK->nl[0])
5137                {                {
5138                md->hitend = TRUE;                md->hitend = TRUE;
5139                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5140                }                }
5141              break;              break;
5142    
5143              case OP_ALLANY:              case OP_ALLANY:
5144              case OP_ANYBYTE:              case OP_ANYBYTE:
5145              break;              break;
# Line 5249  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 5272  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 5301  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 5330  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 5347  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 5557  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 5581  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            }            }
5485    
5486          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5644  for (;;) Line 5527  for (;;)
5527                if (md->partial != 0 &&    /* Take care with CRLF partial */                if (md->partial != 0 &&    /* Take care with CRLF partial */
5528                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5529                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5530                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5531                    *eptr == NLBLOCK->nl[0])                    *eptr == NLBLOCK->nl[0])
5532                  {                  {
5533                  md->hitend = TRUE;                  md->hitend = TRUE;
5534                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5535                  }                  }
# Line 5670  for (;;) Line 5553  for (;;)
5553                if (md->partial != 0 &&    /* Take care with CRLF partial */                if (md->partial != 0 &&    /* Take care with CRLF partial */
5554                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5555                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5556                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5557                    *eptr == NLBLOCK->nl[0])                    *eptr == NLBLOCK->nl[0])
5558                  {                  {
5559                  md->hitend = TRUE;                  md->hitend = TRUE;
5560                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5561                  }                  }
# Line 5725  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 5756  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 5798  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 5921  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 5943  for (;;) Line 5801  for (;;)
5801              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
5802                  eptr + 1 >= md->end_subject &&                  eptr + 1 >= md->end_subject &&
5803                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
5804                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
5805                  *eptr == NLBLOCK->nl[0])                  *eptr == NLBLOCK->nl[0])
5806                {                {
5807                md->hitend = TRUE;                md->hitend = TRUE;
5808                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5809                }                }
# Line 5973  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 5999  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 6018  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 6037  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 6055  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 6159  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    
# Line 6279  Undefine all the macros that were define Line 6147  Undefine all the macros that were define
6147  ***************************************************************************/  ***************************************************************************/
6148    
6149    
6150    #ifdef NO_RECURSE
6151    /*************************************************
6152    *          Release allocated heap frames         *
6153    *************************************************/
6154    
6155    /* This function releases all the allocated frames. The base frame is on the
6156    machine stack, and so must not be freed.
6157    
6158    Argument: the address of the base frame
6159    Returns:  nothing
6160    */
6161    
6162    static void
6163    release_match_heapframes (heapframe *frame_base)
6164    {
6165    heapframe *nextframe = frame_base->Xnextframe;
6166    while (nextframe != NULL)
6167      {
6168      heapframe *oldframe = nextframe;
6169      nextframe = nextframe->Xnextframe;
6170      (PUBL(stack_free))(oldframe);
6171      }
6172    }
6173    #endif
6174    
6175    
6176  /*************************************************  /*************************************************
6177  *         Execute a Regular Expression           *  *         Execute a Regular Expression           *
# Line 6341  PCRE_PUCHAR req_char_ptr = start_match - Line 6234  PCRE_PUCHAR req_char_ptr = start_match -
6234  const pcre_study_data *study;  const pcre_study_data *study;
6235  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
6236    
6237    #ifdef NO_RECURSE
6238    heapframe frame_zero;
6239    frame_zero.Xprevframe = NULL;            /* Marks the top level */
6240    frame_zero.Xnextframe = NULL;            /* None are allocated yet */
6241    md->match_frames_base = &frame_zero;
6242    #endif
6243    
6244  /* Check for the special magic call that measures the size of the stack used  /* Check for the special magic call that measures the size of the stack used
6245  per recursive call of match(). Without the funny casting for sizeof, a Windows  per recursive call of match(). Without the funny casting for sizeof, a Windows
6246  compiler gave this error: "unary minus operator applied to unsigned type,  compiler gave this error: "unary minus operator applied to unsigned type,
6247  result still unsigned". Hopefully the cast fixes that. */  result still unsigned". Hopefully the cast fixes that. */
6248    
# Line 6427  if (extra_data != NULL Line 6327  if (extra_data != NULL
6327                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |
6328                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)
6329    {    {
6330    rc = PRIV(jit_exec)(re, extra_data->executable_jit,    rc = PRIV(jit_exec)(re, extra_data, (const pcre_uchar *)subject, length,
6331      (const pcre_uchar *)subject, length, start_offset, options,         start_offset, options, offsets, offsetcount);
6332      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)  
     ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);  
   
6333    /* PCRE_ERROR_NULL means that the selected normal or partial matching    /* PCRE_ERROR_NULL means that the selected normal or partial matching
6334    mode is not compiled. In this case we simply fallback to interpreter. */    mode is not compiled. In this case we simply fallback to interpreter. */
6335    
6336    if (rc != PCRE_ERROR_NULL)     /* JIT was used */    if (rc != PCRE_ERROR_NULL) return rc;
     {  
     ((pcre_extra *)extra_data)->flags |= PCRE_EXTRA_USED_JIT;  
     return rc;  
     }  
6337    }    }
6338  #endif  #endif
6339    
# Line 6474  if (extra_data != NULL) Line 6368  if (extra_data != NULL)
6368    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
6369      md->callout_data = extra_data->callout_data;      md->callout_data = extra_data->callout_data;
6370    if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;    if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;
   ((pcre_extra *)extra_data)->flags &= ~PCRE_EXTRA_USED_JIT;   /* JIT not used */  
6371    }    }
6372    
6373  /* If the exec call supplied NULL for tables, use the inbuilt ones. This  /* If the exec call supplied NULL for tables, use the inbuilt ones. This
# Line 7035  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6928  if (rc == MATCH_MATCH || rc == MATCH_ACC
6928      {      {
6929      register int *iptr, *iend;      register int *iptr, *iend;
6930      int resetcount = 2 + re->top_bracket * 2;      int resetcount = 2 + re->top_bracket * 2;
6931      if (resetcount > offsetcount) resetcount = ocount;      if (resetcount > offsetcount) resetcount = offsetcount;
6932      iptr = offsets + md->end_offset_top;      iptr = offsets + md->end_offset_top;
6933      iend = offsets + resetcount;      iend = offsets + resetcount;
6934      while (iptr < iend) *iptr++ = -1;      while (iptr < iend) *iptr++ = -1;
# Line 7056  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6949  if (rc == MATCH_MATCH || rc == MATCH_ACC
6949    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6950      *(extra_data->mark) = (pcre_uchar *)md->mark;      *(extra_data->mark) = (pcre_uchar *)md->mark;
6951    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
6952    #ifdef NO_RECURSE
6953      release_match_heapframes(&frame_zero);
6954    #endif
6955    return rc;    return rc;
6956    }    }
6957    
# Line 7073  if (using_temporary_offsets) Line 6969  if (using_temporary_offsets)
6969  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
6970    {    {
6971    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
6972    #ifdef NO_RECURSE
6973      release_match_heapframes(&frame_zero);
6974    #endif
6975    return rc;    return rc;
6976    }    }
6977    
# Line 7102  else Line 7001  else
7001    
7002  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
7003    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;
7004    #ifdef NO_RECURSE
7005      release_match_heapframes(&frame_zero);
7006    #endif
7007  return rc;  return rc;
7008  }  }
7009    

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

  ViewVC Help
Powered by ViewVC 1.1.5