/[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 922 by ph10, Mon Feb 20 18:44:42 2012 UTC revision 1041 by ph10, Sun Sep 16 10:16:27 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 220  are in UTF-8 mode. */ Line 219  are in UTF-8 mode. */
219    
220  else  else
221    {    {
222    while (length-- > 0)    while (length-- > 0)
223      {      {
224      if (eptr >= md->end_subject) return -2;   /* Partial match */      if (eptr >= md->end_subject) return -2;   /* Partial match */
225      if (*p++ != *eptr++) return -1;      if (*p++ != *eptr++) return -1;
226      }      }
227    }    }
228    
229  return (int)(eptr - eptr_start);  return (int)(eptr - eptr_start);
# Line 317  argument of match(), which never changes Line 316  argument of match(), which never changes
316    
317  #define RMATCH(ra,rb,rc,rd,re,rw)\  #define RMATCH(ra,rb,rc,rd,re,rw)\
318    {\    {\
319    heapframe *newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\    heapframe *newframe = frame->Xnextframe;\
320    if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\    if (newframe == NULL)\
321    frame->Xwhere = rw; \      {\
322        newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
323        if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
324        newframe->Xnextframe = NULL;\
325        frame->Xnextframe = newframe;\
326        }\
327      frame->Xwhere = rw;\
328    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
329    newframe->Xecode = rb;\    newframe->Xecode = rb;\
330    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
# Line 338  argument of match(), which never changes Line 343  argument of match(), which never changes
343    {\    {\
344    heapframe *oldframe = frame;\    heapframe *oldframe = frame;\
345    frame = oldframe->Xprevframe;\    frame = oldframe->Xprevframe;\
   if (oldframe != &frame_zero) (PUBL(stack_free))(oldframe);\  
346    if (frame != NULL)\    if (frame != NULL)\
347      {\      {\
348      rrc = ra;\      rrc = ra;\
# Line 352  argument of match(), which never changes Line 356  argument of match(), which never changes
356    
357  typedef struct heapframe {  typedef struct heapframe {
358    struct heapframe *Xprevframe;    struct heapframe *Xprevframe;
359      struct heapframe *Xnextframe;
360    
361    /* Function arguments that may change */    /* Function arguments that may change */
362    
# Line 498  the top-level on the stack rather than m Line 503  the top-level on the stack rather than m
503  boost in many cases where there is not much "recursion". */  boost in many cases where there is not much "recursion". */
504    
505  #ifdef NO_RECURSE  #ifdef NO_RECURSE
506  heapframe frame_zero;  heapframe *frame = (heapframe *)md->match_frames_base;
 heapframe *frame = &frame_zero;  
 frame->Xprevframe = NULL;            /* Marks the top level */  
507    
508  /* Copy in the original argument variables */  /* Copy in the original argument variables */
509    
# Line 903  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 1032  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 1571  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 1785  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 1999  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 2008  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 2065  for (;;) Line 2072  for (;;)
2072    
2073      case OP_DOLLM:      case OP_DOLLM:
2074      if (eptr < md->end_subject)      if (eptr < md->end_subject)
2075        {        {
2076        if (!IS_NEWLINE(eptr))        if (!IS_NEWLINE(eptr))
2077          {          {
2078          if (md->partial != 0 &&          if (md->partial != 0 &&
2079              eptr + 1 >= md->end_subject &&              eptr + 1 >= md->end_subject &&
2080              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
2081              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
2082              *eptr == NLBLOCK->nl[0])              *eptr == NLBLOCK->nl[0])
2083            {            {
2084            md->hitend = TRUE;            md->hitend = TRUE;
2085            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2086            }            }
2087          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2088          }          }
2089        }        }
2090      else      else
2091        {        {
# Line 2115  for (;;) Line 2122  for (;;)
2122        if (md->partial != 0 &&        if (md->partial != 0 &&
2123            eptr + 1 >= md->end_subject &&            eptr + 1 >= md->end_subject &&
2124            NLBLOCK->nltype == NLTYPE_FIXED &&            NLBLOCK->nltype == NLTYPE_FIXED &&
2125            NLBLOCK->nllen == 2 &&            NLBLOCK->nllen == 2 &&
2126            *eptr == NLBLOCK->nl[0])            *eptr == NLBLOCK->nl[0])
2127          {          {
2128          md->hitend = TRUE;          md->hitend = TRUE;
2129          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2130          }          }
2131        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2132        }        }
2133    
2134      /* Either at end of string or \n before end. */      /* Either at end of string or \n before end. */
2135    
# Line 2258  for (;;) Line 2265  for (;;)
2265      if (md->partial != 0 &&      if (md->partial != 0 &&
2266          eptr + 1 >= md->end_subject &&          eptr + 1 >= md->end_subject &&
2267          NLBLOCK->nltype == NLTYPE_FIXED &&          NLBLOCK->nltype == NLTYPE_FIXED &&
2268          NLBLOCK->nllen == 2 &&          NLBLOCK->nllen == 2 &&
2269          *eptr == NLBLOCK->nl[0])          *eptr == NLBLOCK->nl[0])
2270        {        {
2271        md->hitend = TRUE;        md->hitend = TRUE;
2272        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2273        }        }
2274    
2275      /* Fall through */      /* Fall through */
2276    
2277      /* Match any single character whatsoever. */      /* Match any single character whatsoever. */
2278    
2279      case OP_ALLANY:      case OP_ALLANY:
2280      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 */
2281        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
# Line 2408  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 2439  for (;;) Line 2448  for (;;)
2448      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2449      switch(c)      switch(c)
2450        {        {
2451          HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
2452        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);  
2453        }        }
2454      ecode++;      ecode++;
2455      break;      break;
# Line 2473  for (;;) Line 2463  for (;;)
2463      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2464      switch(c)      switch(c)
2465        {        {
2466          HSPACE_CASES: break;  /* Byte and multibyte cases */
2467        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;  
2468        }        }
2469      ecode++;      ecode++;
2470      break;      break;
# Line 2507  for (;;) Line 2478  for (;;)
2478      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2479      switch(c)      switch(c)
2480        {        {
2481          VSPACE_CASES: RRETURN(MATCH_NOMATCH);
2482        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);  
2483        }        }
2484      ecode++;      ecode++;
2485      break;      break;
# Line 2529  for (;;) Line 2493  for (;;)
2493      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2494      switch(c)      switch(c)
2495        {        {
2496          VSPACE_CASES: break;
2497        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;  
2498        }        }
2499      ecode++;      ecode++;
2500      break;      break;
# Line 2634  for (;;) Line 2591  for (;;)
2591        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2592        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2593        }        }
2594      GETCHARINCTEST(c, eptr);      else
     if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
     while (eptr < md->end_subject)  
2595        {        {
2596        int len = 1;        int lgb, rgb;
2597        if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }        GETCHARINCTEST(c, eptr);
2598        if (UCD_CATEGORY(c) != ucp_M) break;        lgb = UCD_GRAPHBREAK(c);
2599        eptr += len;        while (eptr < md->end_subject)
2600            {
2601            int len = 1;
2602            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2603            rgb = UCD_GRAPHBREAK(c);
2604            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2605            lgb = rgb;
2606            eptr += len;
2607            }
2608        }        }
2609      CHECK_PARTIAL();      CHECK_PARTIAL();
2610      ecode++;      ecode++;
2611      break;      break;
2612  #endif  #endif
# Line 2709  for (;;) Line 2672  for (;;)
2672        default:               /* No repeat follows */        default:               /* No repeat follows */
2673        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2674          {          {
2675          if (length == -2) eptr = md->end_subject;   /* Partial match */          if (length == -2) eptr = md->end_subject;   /* Partial match */
2676          CHECK_PARTIAL();          CHECK_PARTIAL();
2677          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2678          }          }
# Line 2735  for (;;) Line 2698  for (;;)
2698        int slength;        int slength;
2699        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2700          {          {
2701          if (slength == -2) eptr = md->end_subject;   /* Partial match */          if (slength == -2) eptr = md->end_subject;   /* Partial match */
2702          CHECK_PARTIAL();          CHECK_PARTIAL();
2703          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2704          }          }
# Line 2759  for (;;) Line 2722  for (;;)
2722          if (fi >= max) RRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2723          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2724            {            {
2725            if (slength == -2) eptr = md->end_subject;   /* Partial match */            if (slength == -2) eptr = md->end_subject;   /* Partial match */
2726            CHECK_PARTIAL();            CHECK_PARTIAL();
2727            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2728            }            }
# Line 2778  for (;;) Line 2741  for (;;)
2741          int slength;          int slength;
2742          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2743            {            {
2744            /* 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
2745            the soft partial matching case. */            the soft partial matching case. */
2746    
2747            if (slength == -2 && md->partial != 0 &&            if (slength == -2 && md->partial != 0 &&
2748                md->end_subject > md->start_used_ptr)                md->end_subject > md->start_used_ptr)
2749              {              {
2750              md->hitend = TRUE;              md->hitend = TRUE;
2751              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2752              }              }
# Line 2791  for (;;) Line 2754  for (;;)
2754            }            }
2755          eptr += slength;          eptr += slength;
2756          }          }
2757    
2758        while (eptr >= pp)        while (eptr >= pp)
2759          {          {
2760          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
# Line 3421  for (;;) Line 3384  for (;;)
3384      maximizing, find the maximum number of characters and work backwards. */      maximizing, find the maximum number of characters and work backwards. */
3385    
3386      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3387        max, eptr));        max, (char *)eptr));
3388    
3389      if (op >= OP_STARI)  /* Caseless */      if (op >= OP_STARI)  /* Caseless */
3390        {        {
# Line 3565  for (;;) Line 3528  for (;;)
3528        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3529        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3530        }        }
3531      ecode++;  #ifdef SUPPORT_UTF
3532      GETCHARINCTEST(c, eptr);      if (utf)
     if (op == OP_NOTI)         /* The caseless case */  
3533        {        {
3534        register unsigned int ch, och;        register unsigned int ch, och;
3535        ch = *ecode++;  
3536  #ifdef COMPILE_PCRE8        ecode++;
3537        /* ch must be < 128 if UTF is enabled. */        GETCHARINC(ch, ecode);
3538        och = md->fcc[ch];        GETCHARINC(c, eptr);
3539  #else  
3540  #ifdef SUPPORT_UTF        if (op == OP_NOT)
3541            {
3542            if (ch == c) RRETURN(MATCH_NOMATCH);
3543            }
3544          else
3545            {
3546  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3547        if (utf && ch > 127)          if (ch > 127)
3548          och = UCD_OTHERCASE(ch);            och = UCD_OTHERCASE(ch);
3549  #else  #else
3550        if (utf && ch > 127)          if (ch > 127)
3551          och = ch;            och = ch;
3552  #endif /* SUPPORT_UCP */  #endif /* SUPPORT_UCP */
3553        else          else
3554  #endif /* SUPPORT_UTF */            och = TABLE_GET(ch, md->fcc, ch);
3555          och = TABLE_GET(ch, md->fcc, ch);          if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
3556  #endif /* COMPILE_PCRE8 */          }
       if (ch == c || och == c) RRETURN(MATCH_NOMATCH);  
3557        }        }
3558      else    /* Caseful */      else
3559    #endif
3560        {        {
3561        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        register unsigned int ch = ecode[1];
3562          c = *eptr++;
3563          if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3564            RRETURN(MATCH_NOMATCH);
3565          ecode += 2;
3566        }        }
3567      break;      break;
3568    
# Line 3671  for (;;) Line 3642  for (;;)
3642      /* Common code for all repeated single-byte matches. */      /* Common code for all repeated single-byte matches. */
3643    
3644      REPEATNOTCHAR:      REPEATNOTCHAR:
3645      fc = *ecode++;      GETCHARINCTEST(fc, ecode);
3646    
3647      /* The code is duplicated for the caseless and caseful cases, for speed,      /* The code is duplicated for the caseless and caseful cases, for speed,
3648      since matching characters is likely to be quite common. First, ensure the      since matching characters is likely to be quite common. First, ensure the
# Line 3682  for (;;) Line 3653  for (;;)
3653      characters and work backwards. */      characters and work backwards. */
3654    
3655      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,
3656        max, eptr));        max, (char *)eptr));
3657    
3658      if (op >= OP_NOTSTARI)     /* Caseless */      if (op >= OP_NOTSTARI)     /* Caseless */
3659        {        {
 #ifdef COMPILE_PCRE8  
       /* fc must be < 128 if UTF is enabled. */  
       foc = md->fcc[fc];  
 #else  
3660  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3661  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3662        if (utf && fc > 127)        if (utf && fc > 127)
# Line 3701  for (;;) Line 3668  for (;;)
3668        else        else
3669  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
3670          foc = TABLE_GET(fc, md->fcc, fc);          foc = TABLE_GET(fc, md->fcc, fc);
 #endif /* COMPILE_PCRE8 */  
3671    
3672  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3673        if (utf)        if (utf)
# Line 3715  for (;;) Line 3681  for (;;)
3681              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3682              }              }
3683            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3684            if (fc == d || (unsigned int) foc == d) RRETURN(MATCH_NOMATCH);            if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3685            }            }
3686          }          }
3687        else        else
# Line 4216  for (;;) Line 4182  for (;;)
4182              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4183              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4184              }              }
4185            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4186              {              {
4187              int len = 1;              int lgb, rgb;
4188              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4189              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4190              eptr += len;             while (eptr < md->end_subject)
4191                  {
4192                  int len = 1;
4193                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4194                  rgb = UCD_GRAPHBREAK(c);
4195                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4196                  lgb = rgb;
4197                  eptr += len;
4198                  }
4199              }              }
4200            CHECK_PARTIAL();            CHECK_PARTIAL();
4201            }            }
4202          }          }
4203    
# Line 4249  for (;;) Line 4221  for (;;)
4221            if (md->partial != 0 &&            if (md->partial != 0 &&
4222                eptr + 1 >= md->end_subject &&                eptr + 1 >= md->end_subject &&
4223                NLBLOCK->nltype == NLTYPE_FIXED &&                NLBLOCK->nltype == NLTYPE_FIXED &&
4224                NLBLOCK->nllen == 2 &&                NLBLOCK->nllen == 2 &&
4225                *eptr == NLBLOCK->nl[0])                *eptr == NLBLOCK->nl[0])
4226              {              {
4227              md->hitend = TRUE;              md->hitend = TRUE;
4228              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4229              }              }
# Line 4291  for (;;) Line 4263  for (;;)
4263              {              {
4264              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4265    
4266              case 0x000d:              case CHAR_CR:
4267              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4268              break;              break;
4269    
4270              case 0x000a:              case CHAR_LF:
4271              break;              break;
4272    
4273              case 0x000b:              case CHAR_VT:
4274              case 0x000c:              case CHAR_FF:
4275              case 0x0085:              case CHAR_NEL:
4276    #ifndef EBCDIC
4277              case 0x2028:              case 0x2028:
4278              case 0x2029:              case 0x2029:
4279    #endif  /* Not EBCDIC */
4280              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4281              break;              break;
4282              }              }
# Line 4320  for (;;) Line 4294  for (;;)
4294            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4295            switch(c)            switch(c)
4296              {              {
4297                HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
4298              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);  
4299              }              }
4300            }            }
4301          break;          break;
# Line 4356  for (;;) Line 4311  for (;;)
4311            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4312            switch(c)            switch(c)
4313              {              {
4314                HSPACE_CASES: break;  /* Byte and multibyte cases */
4315              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;  
4316              }              }
4317            }            }
4318          break;          break;
# Line 4392  for (;;) Line 4328  for (;;)
4328            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4329            switch(c)            switch(c)
4330              {              {
4331                VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4332              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);  
4333              }              }
4334            }            }
4335          break;          break;
# Line 4416  for (;;) Line 4345  for (;;)
4345            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4346            switch(c)            switch(c)
4347              {              {
4348                VSPACE_CASES: break;
4349              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;  
4350              }              }
4351            }            }
4352          break;          break;
# Line 4542  for (;;) Line 4464  for (;;)
4464            if (md->partial != 0 &&            if (md->partial != 0 &&
4465                eptr + 1 >= md->end_subject &&                eptr + 1 >= md->end_subject &&
4466                NLBLOCK->nltype == NLTYPE_FIXED &&                NLBLOCK->nltype == NLTYPE_FIXED &&
4467                NLBLOCK->nllen == 2 &&                NLBLOCK->nllen == 2 &&
4468                *eptr == NLBLOCK->nl[0])                *eptr == NLBLOCK->nl[0])
4469              {              {
4470              md->hitend = TRUE;              md->hitend = TRUE;
4471              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4472              }              }
# Line 4582  for (;;) Line 4504  for (;;)
4504              {              {
4505              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4506    
4507              case 0x000d:              case CHAR_CR:
4508              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4509              break;              break;
4510    
4511              case 0x000a:              case CHAR_LF:
4512              break;              break;
4513    
4514              case 0x000b:              case CHAR_VT:
4515              case 0x000c:              case CHAR_FF:
4516              case 0x0085:              case CHAR_NEL:
4517  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4518              case 0x2028:              case 0x2028:
4519              case 0x2029:              case 0x2029:
# Line 4613  for (;;) Line 4535  for (;;)
4535            switch(*eptr++)            switch(*eptr++)
4536              {              {
4537              default: break;              default: break;
4538              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
4539  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4540              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 */  
4541  #endif  #endif
4542              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4543              }              }
# Line 4650  for (;;) Line 4555  for (;;)
4555            switch(*eptr++)            switch(*eptr++)
4556              {              {
4557              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4558              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
4559  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4560              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 */  
4561  #endif  #endif
4562              break;              break;
4563              }              }
# Line 4686  for (;;) Line 4574  for (;;)
4574              }              }
4575            switch(*eptr++)            switch(*eptr++)
4576              {              {
4577              default: break;              VSPACE_BYTE_CASES:
             case 0x0a:      /* LF */  
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
4578  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4579              case 0x2028:    /* LINE SEPARATOR */              VSPACE_MULTIBYTE_CASES:
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4580  #endif  #endif
4581              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4582                default: break;
4583              }              }
4584            }            }
4585          break;          break;
# Line 4712  for (;;) Line 4595  for (;;)
4595            switch(*eptr++)            switch(*eptr++)
4596              {              {
4597              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4598              case 0x0a:      /* LF */              VSPACE_BYTE_CASES:
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
4599  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4600              case 0x2028:    /* LINE SEPARATOR */              VSPACE_MULTIBYTE_CASES:
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4601  #endif  #endif
4602              break;              break;
4603              }              }
# Line 5019  for (;;) Line 4897  for (;;)
4897              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4898              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4899              }              }
4900            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4901              {              {
4902              int len = 1;              int lgb, rgb;
4903              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4904              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4905              eptr += len;              while (eptr < md->end_subject)
4906                  {
4907                  int len = 1;
4908                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4909                  rgb = UCD_GRAPHBREAK(c);
4910                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4911                  lgb = rgb;
4912                  eptr += len;
4913                  }
4914              }              }
4915            CHECK_PARTIAL();            CHECK_PARTIAL();
4916            }            }
4917          }          }
4918        else        else
# Line 5056  for (;;) Line 4940  for (;;)
4940              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
4941                  eptr >= md->end_subject &&                  eptr >= md->end_subject &&
4942                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
4943                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
4944                  c == NLBLOCK->nl[0])                  c == NLBLOCK->nl[0])
4945                {                {
4946                md->hitend = TRUE;                md->hitend = TRUE;
4947                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4948                }                }
4949              break;              break;
4950    
4951              case OP_ALLANY:              case OP_ALLANY:
4952              case OP_ANYBYTE:              case OP_ANYBYTE:
4953              break;              break;
# Line 5072  for (;;) Line 4956  for (;;)
4956              switch(c)              switch(c)
4957                {                {
4958                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4959                case 0x000d:                case CHAR_CR:
4960                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4961                break;                break;
4962                case 0x000a:  
4963                  case CHAR_LF:
4964                break;                break;
4965    
4966                case 0x000b:                case CHAR_VT:
4967                case 0x000c:                case CHAR_FF:
4968                case 0x0085:                case CHAR_NEL:
4969    #ifndef EBCDIC
4970                case 0x2028:                case 0x2028:
4971                case 0x2029:                case 0x2029:
4972    #endif  /* Not EBCDIC */
4973                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4974                break;                break;
4975                }                }
# Line 5091  for (;;) Line 4978  for (;;)
4978              case OP_NOT_HSPACE:              case OP_NOT_HSPACE:
4979              switch(c)              switch(c)
4980                {                {
4981                  HSPACE_CASES: RRETURN(MATCH_NOMATCH);
4982                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);  
4983                }                }
4984              break;              break;
4985    
4986              case OP_HSPACE:              case OP_HSPACE:
4987              switch(c)              switch(c)
4988                {                {
4989                  HSPACE_CASES: break;
4990                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;  
4991                }                }
4992              break;              break;
4993    
4994              case OP_NOT_VSPACE:              case OP_NOT_VSPACE:
4995              switch(c)              switch(c)
4996                {                {
4997                  VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4998                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);  
4999                }                }
5000              break;              break;
5001    
5002              case OP_VSPACE:              case OP_VSPACE:
5003              switch(c)              switch(c)
5004                {                {
5005                  VSPACE_CASES: break;
5006                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;  
5007                }                }
5008              break;              break;
5009    
# Line 5230  for (;;) Line 5065  for (;;)
5065              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
5066                  eptr >= md->end_subject &&                  eptr >= md->end_subject &&
5067                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
5068                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
5069                  c == NLBLOCK->nl[0])                  c == NLBLOCK->nl[0])
5070                {                {
5071                md->hitend = TRUE;                md->hitend = TRUE;
5072                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5073                }                }
5074              break;              break;
5075    
5076              case OP_ALLANY:              case OP_ALLANY:
5077              case OP_ANYBYTE:              case OP_ANYBYTE:
5078              break;              break;
# Line 5246  for (;;) Line 5081  for (;;)
5081              switch(c)              switch(c)
5082                {                {
5083                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5084                case 0x000d:                case CHAR_CR:
5085                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5086                break;                break;
5087    
5088                case 0x000a:                case CHAR_LF:
5089                break;                break;
5090    
5091                case 0x000b:                case CHAR_VT:
5092                case 0x000c:                case CHAR_FF:
5093                case 0x0085:                case CHAR_NEL:
5094  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5095                case 0x2028:                case 0x2028:
5096                case 0x2029:                case 0x2029:
# Line 5269  for (;;) Line 5104  for (;;)
5104              switch(c)              switch(c)
5105                {                {
5106                default: break;                default: break;
5107                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
5108  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5109                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 */  
5110  #endif  #endif
5111                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5112                }                }
# Line 5298  for (;;) Line 5116  for (;;)
5116              switch(c)              switch(c)
5117                {                {
5118                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5119                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
5120  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5121                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 */  
5122  #endif  #endif
5123                break;                break;
5124                }                }
# Line 5327  for (;;) Line 5128  for (;;)
5128              switch(c)              switch(c)
5129                {                {
5130                default: break;                default: break;
5131                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
5132  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5133                case 0x2028:    /* LINE SEPARATOR */                VSPACE_MULTIBYTE_CASES:
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5134  #endif  #endif
5135                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5136                }                }
# Line 5344  for (;;) Line 5140  for (;;)
5140              switch(c)              switch(c)
5141                {                {
5142                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5143                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
5144  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5145                case 0x2028:    /* LINE SEPARATOR */                VSPACE_MULTIBYTE_CASES:
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5146  #endif  #endif
5147                break;                break;
5148                }                }
# Line 5578  for (;;) Line 5369  for (;;)
5369          {          {
5370          for (i = min; i < max; i++)          for (i = min; i < max; i++)
5371            {            {
           int len = 1;  
5372            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
5373              {              {
5374              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5375              break;              break;
5376              }              }
5377            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }            else
           if (UCD_CATEGORY(c) == ucp_M) break;  
           eptr += len;  
           while (eptr < md->end_subject)  
5378              {              {
5379              len = 1;              int lgb, rgb;
5380              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
5381              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
5382              eptr += len;              while (eptr < md->end_subject)
5383                  {
5384                  int len = 1;
5385                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5386                  rgb = UCD_GRAPHBREAK(c);
5387                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5388                  lgb = rgb;
5389                  eptr += len;
5390                  }
5391              }              }
5392            CHECK_PARTIAL();            CHECK_PARTIAL();
5393            }            }
5394    
5395          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5641  for (;;) Line 5436  for (;;)
5436                if (md->partial != 0 &&    /* Take care with CRLF partial */                if (md->partial != 0 &&    /* Take care with CRLF partial */
5437                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5438                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5439                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5440                    *eptr == NLBLOCK->nl[0])                    *eptr == NLBLOCK->nl[0])
5441                  {                  {
5442                  md->hitend = TRUE;                  md->hitend = TRUE;
5443                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5444                  }                  }
# Line 5667  for (;;) Line 5462  for (;;)
5462                if (md->partial != 0 &&    /* Take care with CRLF partial */                if (md->partial != 0 &&    /* Take care with CRLF partial */
5463                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5464                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5465                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5466                    *eptr == NLBLOCK->nl[0])                    *eptr == NLBLOCK->nl[0])
5467                  {                  {
5468                  md->hitend = TRUE;                  md->hitend = TRUE;
5469                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5470                  }                  }
# Line 5722  for (;;) Line 5517  for (;;)
5517                break;                break;
5518                }                }
5519              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5520              if (c == 0x000d)              if (c == CHAR_CR)
5521                {                {
5522                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5523                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5524                }                }
5525              else              else
5526                {                {
5527                if (c != 0x000a &&                if (c != CHAR_LF &&
5528                    (md->bsr_anycrlf ||                    (md->bsr_anycrlf ||
5529                     (c != 0x000b && c != 0x000c &&                     (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5530                      c != 0x0085 && c != 0x2028 && c != 0x2029)))  #ifndef EBCDIC
5531                        && c != 0x2028 && c != 0x2029
5532    #endif  /* Not EBCDIC */
5533                        )))
5534                  break;                  break;
5535                eptr += len;                eptr += len;
5536                }                }
# Line 5753  for (;;) Line 5551  for (;;)
5551              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5552              switch(c)              switch(c)
5553                {                {
5554                  HSPACE_CASES: gotspace = TRUE; break;
5555                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;  
5556                }                }
5557              if (gotspace == (ctype == OP_NOT_HSPACE)) break;              if (gotspace == (ctype == OP_NOT_HSPACE)) break;
5558              eptr += len;              eptr += len;
# Line 5795  for (;;) Line 5573  for (;;)
5573              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5574              switch(c)              switch(c)
5575                {                {
5576                  VSPACE_CASES: gotspace = TRUE; break;
5577                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;  
5578                }                }
5579              if (gotspace == (ctype == OP_NOT_VSPACE)) break;              if (gotspace == (ctype == OP_NOT_VSPACE)) break;
5580              eptr += len;              eptr += len;
# Line 5918  for (;;) Line 5688  for (;;)
5688            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5689            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5690            BACKCHAR(eptr);            BACKCHAR(eptr);
5691            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_NL &&
5692                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
5693            }            }
5694          }          }
5695        else        else
# Line 5940  for (;;) Line 5710  for (;;)
5710              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
5711                  eptr + 1 >= md->end_subject &&                  eptr + 1 >= md->end_subject &&
5712                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
5713                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
5714                  *eptr == NLBLOCK->nl[0])                  *eptr == NLBLOCK->nl[0])
5715                {                {
5716                md->hitend = TRUE;                md->hitend = TRUE;
5717                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5718                }                }
# Line 5970  for (;;) Line 5740  for (;;)
5740                break;                break;
5741                }                }
5742              c = *eptr;              c = *eptr;
5743              if (c == 0x000d)              if (c == CHAR_CR)
5744                {                {
5745                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5746                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5747                }                }
5748              else              else
5749                {                {
5750                if (c != 0x000a && (md->bsr_anycrlf ||                if (c != CHAR_LF && (md->bsr_anycrlf ||
5751                  (c != 0x000b && c != 0x000c && c != 0x0085                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5752  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5753                  && c != 0x2028 && c != 0x2029                   && c != 0x2028 && c != 0x2029
5754  #endif  #endif
5755                  ))) break;                   ))) break;
5756                eptr++;                eptr++;
5757                }                }
5758              }              }
# Line 5996  for (;;) Line 5766  for (;;)
5766                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5767                break;                break;
5768                }                }
5769              c = *eptr;              switch(*eptr)
5770              if (c == 0x09 || c == 0x20 || c == 0xa0                {
5771                  default: eptr++; break;
5772                  HSPACE_BYTE_CASES:
5773  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5774                || c == 0x1680 || c == 0x180e || (c >= 0x2000 && c <= 0x200A)                HSPACE_MULTIBYTE_CASES:
               || c == 0x202f || c == 0x205f || c == 0x3000  
5775  #endif  #endif
5776                ) break;                goto ENDLOOP00;
5777              eptr++;                }
5778              }              }
5779              ENDLOOP00:
5780            break;            break;
5781    
5782            case OP_HSPACE:            case OP_HSPACE:
# Line 6015  for (;;) Line 5787  for (;;)
5787                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5788                break;                break;
5789                }                }
5790              c = *eptr;              switch(*eptr)
5791              if (c != 0x09 && c != 0x20 && c != 0xa0                {
5792                  default: goto ENDLOOP01;
5793                  HSPACE_BYTE_CASES:
5794  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5795                && c != 0x1680 && c != 0x180e && (c < 0x2000 || c > 0x200A)                HSPACE_MULTIBYTE_CASES:
               && c != 0x202f && c != 0x205f && c != 0x3000  
5796  #endif  #endif
5797                ) break;                eptr++; break;
5798              eptr++;                }
5799              }              }
5800              ENDLOOP01:
5801            break;            break;
5802    
5803            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
# Line 6034  for (;;) Line 5808  for (;;)
5808                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5809                break;                break;
5810                }                }
5811              c = *eptr;              switch(*eptr)
5812              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85                {
5813                  default: eptr++; break;
5814                  VSPACE_BYTE_CASES:
5815  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5816                || c == 0x2028 || c == 0x2029                VSPACE_MULTIBYTE_CASES:
5817  #endif  #endif
5818                ) break;                goto ENDLOOP02;
5819              eptr++;                }
5820              }              }
5821              ENDLOOP02:
5822            break;            break;
5823    
5824            case OP_VSPACE:            case OP_VSPACE:
# Line 6052  for (;;) Line 5829  for (;;)
5829                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5830                break;                break;
5831                }                }
5832              c = *eptr;              switch(*eptr)
5833              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85                {
5834                  default: goto ENDLOOP03;
5835                  VSPACE_BYTE_CASES:
5836  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5837                && c != 0x2028 && c != 0x2029                VSPACE_MULTIBYTE_CASES:
5838  #endif  #endif
5839                ) break;                eptr++; break;
5840              eptr++;                }
5841              }              }
5842              ENDLOOP03:
5843            break;            break;
5844    
5845            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
# Line 6156  for (;;) Line 5936  for (;;)
5936            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
5937            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5938            eptr--;            eptr--;
5939            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_LF &&
5940                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
5941            }            }
5942          }          }
5943    
# Line 6276  Undefine all the macros that were define Line 6056  Undefine all the macros that were define
6056  ***************************************************************************/  ***************************************************************************/
6057    
6058    
6059    #ifdef NO_RECURSE
6060    /*************************************************
6061    *          Release allocated heap frames         *
6062    *************************************************/
6063    
6064    /* This function releases all the allocated frames. The base frame is on the
6065    machine stack, and so must not be freed.
6066    
6067    Argument: the address of the base frame
6068    Returns:  nothing
6069    */
6070    
6071    static void
6072    release_match_heapframes (heapframe *frame_base)
6073    {
6074    heapframe *nextframe = frame_base->Xnextframe;
6075    while (nextframe != NULL)
6076      {
6077      heapframe *oldframe = nextframe;
6078      nextframe = nextframe->Xnextframe;
6079      (PUBL(stack_free))(oldframe);
6080      }
6081    }
6082    #endif
6083    
6084    
6085  /*************************************************  /*************************************************
6086  *         Execute a Regular Expression           *  *         Execute a Regular Expression           *
# Line 6338  PCRE_PUCHAR req_char_ptr = start_match - Line 6143  PCRE_PUCHAR req_char_ptr = start_match -
6143  const pcre_study_data *study;  const pcre_study_data *study;
6144  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
6145    
6146    #ifdef NO_RECURSE
6147    heapframe frame_zero;
6148    frame_zero.Xprevframe = NULL;            /* Marks the top level */
6149    frame_zero.Xnextframe = NULL;            /* None are allocated yet */
6150    md->match_frames_base = &frame_zero;
6151    #endif
6152    
6153  /* 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
6154  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
6155  compiler gave this error: "unary minus operator applied to unsigned type,  compiler gave this error: "unary minus operator applied to unsigned type,
6156  result still unsigned". Hopefully the cast fixes that. */  result still unsigned". Hopefully the cast fixes that. */
6157    
# Line 6424  if (extra_data != NULL Line 6236  if (extra_data != NULL
6236                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |
6237                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)
6238    {    {
6239    rc = PRIV(jit_exec)(re, extra_data->executable_jit,    rc = PRIV(jit_exec)(re, extra_data, (const pcre_uchar *)subject, length,
6240      (const pcre_uchar *)subject, length, start_offset, options,         start_offset, options, offsets, offsetcount);
6241      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)  
     ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);  
   
6242    /* PCRE_ERROR_NULL means that the selected normal or partial matching    /* PCRE_ERROR_NULL means that the selected normal or partial matching
6243    mode is not compiled. In this case we simply fallback to interpreter. */    mode is not compiled. In this case we simply fallback to interpreter. */
6244    
6245    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;  
     }  
6246    }    }
6247  #endif  #endif
6248    
# Line 6471  if (extra_data != NULL) Line 6277  if (extra_data != NULL)
6277    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
6278      md->callout_data = extra_data->callout_data;      md->callout_data = extra_data->callout_data;
6279    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 */  
6280    }    }
6281    
6282  /* 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 7032  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6837  if (rc == MATCH_MATCH || rc == MATCH_ACC
6837      {      {
6838      register int *iptr, *iend;      register int *iptr, *iend;
6839      int resetcount = 2 + re->top_bracket * 2;      int resetcount = 2 + re->top_bracket * 2;
6840      if (resetcount > offsetcount) resetcount = ocount;      if (resetcount > offsetcount) resetcount = offsetcount;
6841      iptr = offsets + md->end_offset_top;      iptr = offsets + md->end_offset_top;
6842      iend = offsets + resetcount;      iend = offsets + resetcount;
6843      while (iptr < iend) *iptr++ = -1;      while (iptr < iend) *iptr++ = -1;
# Line 7053  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6858  if (rc == MATCH_MATCH || rc == MATCH_ACC
6858    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6859      *(extra_data->mark) = (pcre_uchar *)md->mark;      *(extra_data->mark) = (pcre_uchar *)md->mark;
6860    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
6861    #ifdef NO_RECURSE
6862      release_match_heapframes(&frame_zero);
6863    #endif
6864    return rc;    return rc;
6865    }    }
6866    
# Line 7070  if (using_temporary_offsets) Line 6878  if (using_temporary_offsets)
6878  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
6879    {    {
6880    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
6881    #ifdef NO_RECURSE
6882      release_match_heapframes(&frame_zero);
6883    #endif
6884    return rc;    return rc;
6885    }    }
6886    
# Line 7099  else Line 6910  else
6910    
6911  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6912    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;
6913    #ifdef NO_RECURSE
6914      release_match_heapframes(&frame_zero);
6915    #endif
6916  return rc;  return rc;
6917  }  }
6918    

Legend:
Removed from v.922  
changed lines
  Added in v.1041

  ViewVC Help
Powered by ViewVC 1.1.5