/[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 1033 by ph10, Mon Sep 10 11:02:48 2012 UTC
# Line 37  POSSIBILITY OF SUCH DAMAGE. Line 37  POSSIBILITY OF SUCH DAMAGE.
37  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
38  */  */
39    
   
40  /* This module contains pcre_exec(), the externally visible function that does  /* This module contains pcre_exec(), the externally visible function that does
41  pattern matching using an NFA algorithm, trying to mimic Perl as closely as  pattern matching using an NFA algorithm, trying to mimic Perl as closely as
42  possible. There are also some static supporting functions. */  possible. There are also some static supporting functions. */
# Line 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 2440  for (;;) Line 2449  for (;;)
2449      switch(c)      switch(c)
2450        {        {
2451        default: break;        default: break;
2452        case 0x09:      /* HT */        case CHAR_HT:
2453        case 0x20:      /* SPACE */        case CHAR_SPACE:
2454    #ifndef EBCDIC
2455        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
2456        case 0x1680:    /* OGHAM SPACE MARK */        case 0x1680:    /* OGHAM SPACE MARK */
2457        case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */        case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 2459  for (;;) Line 2469  for (;;)
2469        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2470        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2471        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2472    #endif  /* Not EBCDIC */
2473        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2474        }        }
2475      ecode++;      ecode++;
# Line 2474  for (;;) Line 2485  for (;;)
2485      switch(c)      switch(c)
2486        {        {
2487        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2488        case 0x09:      /* HT */        case CHAR_HT:
2489        case 0x20:      /* SPACE */        case CHAR_SPACE:
2490    #ifndef EBCDIC
2491        case 0xa0:      /* NBSP */        case 0xa0:      /* NBSP */
2492        case 0x1680:    /* OGHAM SPACE MARK */        case 0x1680:    /* OGHAM SPACE MARK */
2493        case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */        case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 2493  for (;;) Line 2505  for (;;)
2505        case 0x202f:    /* NARROW NO-BREAK SPACE */        case 0x202f:    /* NARROW NO-BREAK SPACE */
2506        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */        case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
2507        case 0x3000:    /* IDEOGRAPHIC SPACE */        case 0x3000:    /* IDEOGRAPHIC SPACE */
2508    #endif  /* Not EBCDIC */
2509        break;        break;
2510        }        }
2511      ecode++;      ecode++;
# Line 2508  for (;;) Line 2521  for (;;)
2521      switch(c)      switch(c)
2522        {        {
2523        default: break;        default: break;
2524        case 0x0a:      /* LF */        case CHAR_LF:
2525        case 0x0b:      /* VT */        case CHAR_VT:
2526        case 0x0c:      /* FF */        case CHAR_FF:
2527        case 0x0d:      /* CR */        case CHAR_CR:
2528        case 0x85:      /* NEL */        case CHAR_NEL:
2529    #ifndef EBCDIC
2530        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2531        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2532    #endif  /* Not EBCDIC */
2533        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2534        }        }
2535      ecode++;      ecode++;
# Line 2530  for (;;) Line 2545  for (;;)
2545      switch(c)      switch(c)
2546        {        {
2547        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2548        case 0x0a:      /* LF */        case CHAR_LF:
2549        case 0x0b:      /* VT */        case CHAR_VT:
2550        case 0x0c:      /* FF */        case CHAR_FF:
2551        case 0x0d:      /* CR */        case CHAR_CR:
2552        case 0x85:      /* NEL */        case CHAR_NEL:
2553    #ifndef EBCDIC
2554        case 0x2028:    /* LINE SEPARATOR */        case 0x2028:    /* LINE SEPARATOR */
2555        case 0x2029:    /* PARAGRAPH SEPARATOR */        case 0x2029:    /* PARAGRAPH SEPARATOR */
2556    #endif  /* Not EBCDIC */
2557        break;        break;
2558        }        }
2559      ecode++;      ecode++;
# Line 2634  for (;;) Line 2651  for (;;)
2651        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2652        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2653        }        }
2654      GETCHARINCTEST(c, eptr);      else
2655      if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);        {
2656      while (eptr < md->end_subject)        int lgb, rgb;
2657        {        GETCHARINCTEST(c, eptr);
2658        int len = 1;        lgb = UCD_GRAPHBREAK(c);
2659        if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }        while (eptr < md->end_subject)
2660        if (UCD_CATEGORY(c) != ucp_M) break;          {
2661        eptr += len;          int len = 1;
2662            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2663            rgb = UCD_GRAPHBREAK(c);
2664            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2665            lgb = rgb;
2666            eptr += len;
2667            }
2668        }        }
2669      CHECK_PARTIAL();      CHECK_PARTIAL();
2670      ecode++;      ecode++;
2671      break;      break;
2672  #endif  #endif
# Line 2709  for (;;) Line 2732  for (;;)
2732        default:               /* No repeat follows */        default:               /* No repeat follows */
2733        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2734          {          {
2735          if (length == -2) eptr = md->end_subject;   /* Partial match */          if (length == -2) eptr = md->end_subject;   /* Partial match */
2736          CHECK_PARTIAL();          CHECK_PARTIAL();
2737          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2738          }          }
# Line 2735  for (;;) Line 2758  for (;;)
2758        int slength;        int slength;
2759        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2760          {          {
2761          if (slength == -2) eptr = md->end_subject;   /* Partial match */          if (slength == -2) eptr = md->end_subject;   /* Partial match */
2762          CHECK_PARTIAL();          CHECK_PARTIAL();
2763          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2764          }          }
# Line 2759  for (;;) Line 2782  for (;;)
2782          if (fi >= max) RRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2783          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2784            {            {
2785            if (slength == -2) eptr = md->end_subject;   /* Partial match */            if (slength == -2) eptr = md->end_subject;   /* Partial match */
2786            CHECK_PARTIAL();            CHECK_PARTIAL();
2787            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2788            }            }
# Line 2778  for (;;) Line 2801  for (;;)
2801          int slength;          int slength;
2802          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2803            {            {
2804            /* 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
2805            the soft partial matching case. */            the soft partial matching case. */
2806    
2807            if (slength == -2 && md->partial != 0 &&            if (slength == -2 && md->partial != 0 &&
2808                md->end_subject > md->start_used_ptr)                md->end_subject > md->start_used_ptr)
2809              {              {
2810              md->hitend = TRUE;              md->hitend = TRUE;
2811              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2812              }              }
# Line 2791  for (;;) Line 2814  for (;;)
2814            }            }
2815          eptr += slength;          eptr += slength;
2816          }          }
2817    
2818        while (eptr >= pp)        while (eptr >= pp)
2819          {          {
2820          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
# Line 3421  for (;;) Line 3444  for (;;)
3444      maximizing, find the maximum number of characters and work backwards. */      maximizing, find the maximum number of characters and work backwards. */
3445    
3446      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3447        max, eptr));        max, (char *)eptr));
3448    
3449      if (op >= OP_STARI)  /* Caseless */      if (op >= OP_STARI)  /* Caseless */
3450        {        {
# Line 3565  for (;;) Line 3588  for (;;)
3588        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3589        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3590        }        }
3591      ecode++;  #ifdef SUPPORT_UTF
3592      GETCHARINCTEST(c, eptr);      if (utf)
     if (op == OP_NOTI)         /* The caseless case */  
3593        {        {
3594        register unsigned int ch, och;        register unsigned int ch, och;
3595        ch = *ecode++;  
3596  #ifdef COMPILE_PCRE8        ecode++;
3597        /* ch must be < 128 if UTF is enabled. */        GETCHARINC(ch, ecode);
3598        och = md->fcc[ch];        GETCHARINC(c, eptr);
3599  #else  
3600  #ifdef SUPPORT_UTF        if (op == OP_NOT)
3601            {
3602            if (ch == c) RRETURN(MATCH_NOMATCH);
3603            }
3604          else
3605            {
3606  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3607        if (utf && ch > 127)          if (ch > 127)
3608          och = UCD_OTHERCASE(ch);            och = UCD_OTHERCASE(ch);
3609  #else  #else
3610        if (utf && ch > 127)          if (ch > 127)
3611          och = ch;            och = ch;
3612  #endif /* SUPPORT_UCP */  #endif /* SUPPORT_UCP */
3613        else          else
3614  #endif /* SUPPORT_UTF */            och = TABLE_GET(ch, md->fcc, ch);
3615          och = TABLE_GET(ch, md->fcc, ch);          if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
3616  #endif /* COMPILE_PCRE8 */          }
       if (ch == c || och == c) RRETURN(MATCH_NOMATCH);  
3617        }        }
3618      else    /* Caseful */      else
3619    #endif
3620        {        {
3621        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        register unsigned int ch = ecode[1];
3622          c = *eptr++;
3623          if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3624            RRETURN(MATCH_NOMATCH);
3625          ecode += 2;
3626        }        }
3627      break;      break;
3628    
# Line 3671  for (;;) Line 3702  for (;;)
3702      /* Common code for all repeated single-byte matches. */      /* Common code for all repeated single-byte matches. */
3703    
3704      REPEATNOTCHAR:      REPEATNOTCHAR:
3705      fc = *ecode++;      GETCHARINCTEST(fc, ecode);
3706    
3707      /* The code is duplicated for the caseless and caseful cases, for speed,      /* The code is duplicated for the caseless and caseful cases, for speed,
3708      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 3713  for (;;)
3713      characters and work backwards. */      characters and work backwards. */
3714    
3715      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3716        max, eptr));        max, (char *)eptr));
3717    
3718      if (op >= OP_NOTSTARI)     /* Caseless */      if (op >= OP_NOTSTARI)     /* Caseless */
3719        {        {
 #ifdef COMPILE_PCRE8  
       /* fc must be < 128 if UTF is enabled. */  
       foc = md->fcc[fc];  
 #else  
3720  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3721  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3722        if (utf && fc > 127)        if (utf && fc > 127)
# Line 3701  for (;;) Line 3728  for (;;)
3728        else        else
3729  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
3730          foc = TABLE_GET(fc, md->fcc, fc);          foc = TABLE_GET(fc, md->fcc, fc);
 #endif /* COMPILE_PCRE8 */  
3731    
3732  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3733        if (utf)        if (utf)
# Line 3715  for (;;) Line 3741  for (;;)
3741              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3742              }              }
3743            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3744            if (fc == d || (unsigned int) foc == d) RRETURN(MATCH_NOMATCH);            if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3745            }            }
3746          }          }
3747        else        else
# Line 4216  for (;;) Line 4242  for (;;)
4242              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4243              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4244              }              }
4245            GETCHARINCTEST(c, eptr);            else
4246            if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);              {
4247            while (eptr < md->end_subject)              int lgb, rgb;
4248              {              GETCHARINCTEST(c, eptr);
4249              int len = 1;              lgb = UCD_GRAPHBREAK(c);
4250              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }             while (eptr < md->end_subject)
4251              if (UCD_CATEGORY(c) != ucp_M) break;                {
4252              eptr += len;                int len = 1;
4253                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4254                  rgb = UCD_GRAPHBREAK(c);
4255                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4256                  lgb = rgb;
4257                  eptr += len;
4258                  }
4259              }              }
4260            CHECK_PARTIAL();            CHECK_PARTIAL();
4261            }            }
4262          }          }
4263    
# Line 4249  for (;;) Line 4281  for (;;)
4281            if (md->partial != 0 &&            if (md->partial != 0 &&
4282                eptr + 1 >= md->end_subject &&                eptr + 1 >= md->end_subject &&
4283                NLBLOCK->nltype == NLTYPE_FIXED &&                NLBLOCK->nltype == NLTYPE_FIXED &&
4284                NLBLOCK->nllen == 2 &&                NLBLOCK->nllen == 2 &&
4285                *eptr == NLBLOCK->nl[0])                *eptr == NLBLOCK->nl[0])
4286              {              {
4287              md->hitend = TRUE;              md->hitend = TRUE;
4288              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4289              }              }
# Line 4291  for (;;) Line 4323  for (;;)
4323              {              {
4324              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4325    
4326              case 0x000d:              case CHAR_CR:
4327              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4328              break;              break;
4329    
4330              case 0x000a:              case CHAR_LF:
4331              break;              break;
4332    
4333              case 0x000b:              case CHAR_VT:
4334              case 0x000c:              case CHAR_FF:
4335              case 0x0085:              case CHAR_NEL:
4336    #ifndef EBCDIC
4337              case 0x2028:              case 0x2028:
4338              case 0x2029:              case 0x2029:
4339    #endif  /* Not EBCDIC */
4340              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4341              break;              break;
4342              }              }
# Line 4321  for (;;) Line 4355  for (;;)
4355            switch(c)            switch(c)
4356              {              {
4357              default: break;              default: break;
4358              case 0x09:      /* HT */              case CHAR_HT:
4359              case 0x20:      /* SPACE */              case CHAR_SPACE:
4360    #ifndef EBCDIC
4361              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4362              case 0x1680:    /* OGHAM SPACE MARK */              case 0x1680:    /* OGHAM SPACE MARK */
4363              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 4340  for (;;) Line 4375  for (;;)
4375              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
4376              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4377              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
4378    #endif  /* Not EBCDIC */
4379              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4380              }              }
4381            }            }
# Line 4357  for (;;) Line 4393  for (;;)
4393            switch(c)            switch(c)
4394              {              {
4395              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4396              case 0x09:      /* HT */              case CHAR_HT:
4397              case 0x20:      /* SPACE */              case CHAR_SPACE:
4398    #ifndef EBCDIC
4399              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4400              case 0x1680:    /* OGHAM SPACE MARK */              case 0x1680:    /* OGHAM SPACE MARK */
4401              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */              case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 4376  for (;;) Line 4413  for (;;)
4413              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
4414              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4415              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
4416    #endif
4417              break;              break;
4418              }              }
4419            }            }
# Line 4393  for (;;) Line 4431  for (;;)
4431            switch(c)            switch(c)
4432              {              {
4433              default: break;              default: break;
4434              case 0x0a:      /* LF */              case CHAR_LF:
4435              case 0x0b:      /* VT */              case CHAR_VT:
4436              case 0x0c:      /* FF */              case CHAR_FF:
4437              case 0x0d:      /* CR */              case CHAR_CR:
4438              case 0x85:      /* NEL */              case CHAR_NEL:
4439    #ifndef EBCDIC
4440              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
4441              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
4442    #endif
4443              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4444              }              }
4445            }            }
# Line 4417  for (;;) Line 4457  for (;;)
4457            switch(c)            switch(c)
4458              {              {
4459              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4460              case 0x0a:      /* LF */              case CHAR_LF:
4461              case 0x0b:      /* VT */              case CHAR_VT:
4462              case 0x0c:      /* FF */              case CHAR_FF:
4463              case 0x0d:      /* CR */              case CHAR_CR:
4464              case 0x85:      /* NEL */              case CHAR_NEL:
4465    #ifndef EBCDIC
4466              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
4467              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
4468    #endif
4469              break;              break;
4470              }              }
4471            }            }
# Line 4542  for (;;) Line 4584  for (;;)
4584            if (md->partial != 0 &&            if (md->partial != 0 &&
4585                eptr + 1 >= md->end_subject &&                eptr + 1 >= md->end_subject &&
4586                NLBLOCK->nltype == NLTYPE_FIXED &&                NLBLOCK->nltype == NLTYPE_FIXED &&
4587                NLBLOCK->nllen == 2 &&                NLBLOCK->nllen == 2 &&
4588                *eptr == NLBLOCK->nl[0])                *eptr == NLBLOCK->nl[0])
4589              {              {
4590              md->hitend = TRUE;              md->hitend = TRUE;
4591              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4592              }              }
# Line 4582  for (;;) Line 4624  for (;;)
4624              {              {
4625              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4626    
4627              case 0x000d:              case CHAR_CR:
4628              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4629              break;              break;
4630    
4631              case 0x000a:              case CHAR_LF:
4632              break;              break;
4633    
4634              case 0x000b:              case CHAR_VT:
4635              case 0x000c:              case CHAR_FF:
4636              case 0x0085:              case CHAR_NEL:
4637  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4638              case 0x2028:              case 0x2028:
4639              case 0x2029:              case 0x2029:
# Line 4613  for (;;) Line 4655  for (;;)
4655            switch(*eptr++)            switch(*eptr++)
4656              {              {
4657              default: break;              default: break;
4658              case 0x09:      /* HT */              case CHAR_HT:
4659              case 0x20:      /* SPACE */              case CHAR_SPACE:
4660    #ifndef EBCDIC
4661              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4662  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4663              case 0x1680:    /* OGHAM SPACE MARK */              case 0x1680:    /* OGHAM SPACE MARK */
# Line 4633  for (;;) Line 4676  for (;;)
4676              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
4677              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4678              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
4679  #endif  #endif  /* COMPILE_PCRE16 */
4680    #endif  /* Not EBCDIC */
4681              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4682              }              }
4683            }            }
# Line 4650  for (;;) Line 4694  for (;;)
4694            switch(*eptr++)            switch(*eptr++)
4695              {              {
4696              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4697              case 0x09:      /* HT */              case CHAR_HT:
4698              case 0x20:      /* SPACE */              case CHAR_SPACE:
4699    #ifndef EBCDIC
4700              case 0xa0:      /* NBSP */              case 0xa0:      /* NBSP */
4701  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4702              case 0x1680:    /* OGHAM SPACE MARK */              case 0x1680:    /* OGHAM SPACE MARK */
# Line 4670  for (;;) Line 4715  for (;;)
4715              case 0x202f:    /* NARROW NO-BREAK SPACE */              case 0x202f:    /* NARROW NO-BREAK SPACE */
4716              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */              case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
4717              case 0x3000:    /* IDEOGRAPHIC SPACE */              case 0x3000:    /* IDEOGRAPHIC SPACE */
4718  #endif  #endif  /* COMPILE_PCRE16 */
4719    #endif  /* Not EBCDIC */
4720              break;              break;
4721              }              }
4722            }            }
# Line 4687  for (;;) Line 4733  for (;;)
4733            switch(*eptr++)            switch(*eptr++)
4734              {              {
4735              default: break;              default: break;
4736              case 0x0a:      /* LF */              case CHAR_LF:
4737              case 0x0b:      /* VT */              case CHAR_VT:
4738              case 0x0c:      /* FF */              case CHAR_FF:
4739              case 0x0d:      /* CR */              case CHAR_CR:
4740              case 0x85:      /* NEL */              case CHAR_NEL:
4741  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4742              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
4743              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
# Line 4712  for (;;) Line 4758  for (;;)
4758            switch(*eptr++)            switch(*eptr++)
4759              {              {
4760              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4761              case 0x0a:      /* LF */              case CHAR_LF:
4762              case 0x0b:      /* VT */              case CHAR_VT:
4763              case 0x0c:      /* FF */              case CHAR_FF:
4764              case 0x0d:      /* CR */              case CHAR_CR:
4765              case 0x85:      /* NEL */              case CHAR_NEL:
4766  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4767              case 0x2028:    /* LINE SEPARATOR */              case 0x2028:    /* LINE SEPARATOR */
4768              case 0x2029:    /* PARAGRAPH SEPARATOR */              case 0x2029:    /* PARAGRAPH SEPARATOR */
# Line 5019  for (;;) Line 5065  for (;;)
5065              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5066              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
5067              }              }
5068            GETCHARINCTEST(c, eptr);            else
5069            if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);              {
5070            while (eptr < md->end_subject)              int lgb, rgb;
5071              {              GETCHARINCTEST(c, eptr);
5072              int len = 1;              lgb = UCD_GRAPHBREAK(c);
5073              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              while (eptr < md->end_subject)
5074              if (UCD_CATEGORY(c) != ucp_M) break;                {
5075              eptr += len;                int len = 1;
5076                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5077                  rgb = UCD_GRAPHBREAK(c);
5078                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5079                  lgb = rgb;
5080                  eptr += len;
5081                  }
5082              }              }
5083            CHECK_PARTIAL();            CHECK_PARTIAL();
5084            }            }
5085          }          }
5086        else        else
# Line 5056  for (;;) Line 5108  for (;;)
5108              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
5109                  eptr >= md->end_subject &&                  eptr >= md->end_subject &&
5110                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
5111                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
5112                  c == NLBLOCK->nl[0])                  c == NLBLOCK->nl[0])
5113                {                {
5114                md->hitend = TRUE;                md->hitend = TRUE;
5115                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5116                }                }
5117              break;              break;
5118    
5119              case OP_ALLANY:              case OP_ALLANY:
5120              case OP_ANYBYTE:              case OP_ANYBYTE:
5121              break;              break;
# Line 5072  for (;;) Line 5124  for (;;)
5124              switch(c)              switch(c)
5125                {                {
5126                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5127                case 0x000d:                case CHAR_CR:
5128                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5129                break;                break;
5130                case 0x000a:  
5131                  case CHAR_LF:
5132                break;                break;
5133    
5134                case 0x000b:                case CHAR_VT:
5135                case 0x000c:                case CHAR_FF:
5136                case 0x0085:                case CHAR_NEL:
5137    #ifndef EBCDIC
5138                case 0x2028:                case 0x2028:
5139                case 0x2029:                case 0x2029:
5140    #endif  /* Not EBCDIC */
5141                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5142                break;                break;
5143                }                }
# Line 5092  for (;;) Line 5147  for (;;)
5147              switch(c)              switch(c)
5148                {                {
5149                default: break;                default: break;
5150                case 0x09:      /* HT */                case CHAR_HT:
5151                case 0x20:      /* SPACE */                case CHAR_SPACE:
5152    #ifndef EBCDIC
5153                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
5154                case 0x1680:    /* OGHAM SPACE MARK */                case 0x1680:    /* OGHAM SPACE MARK */
5155                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 5111  for (;;) Line 5167  for (;;)
5167                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
5168                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5169                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
5170    #endif  /* Not EBCDIC */
5171                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5172                }                }
5173              break;              break;
# Line 5119  for (;;) Line 5176  for (;;)
5176              switch(c)              switch(c)
5177                {                {
5178                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5179                case 0x09:      /* HT */                case CHAR_HT:
5180                case 0x20:      /* SPACE */                case CHAR_SPACE:
5181    #ifndef EBCDIC
5182                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
5183                case 0x1680:    /* OGHAM SPACE MARK */                case 0x1680:    /* OGHAM SPACE MARK */
5184                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 5138  for (;;) Line 5196  for (;;)
5196                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
5197                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5198                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
5199    #endif  /* Not EBCDIC */
5200                break;                break;
5201                }                }
5202              break;              break;
# Line 5146  for (;;) Line 5205  for (;;)
5205              switch(c)              switch(c)
5206                {                {
5207                default: break;                default: break;
5208                case 0x0a:      /* LF */                case CHAR_LF:
5209                case 0x0b:      /* VT */                case CHAR_VT:
5210                case 0x0c:      /* FF */                case CHAR_FF:
5211                case 0x0d:      /* CR */                case CHAR_CR:
5212                case 0x85:      /* NEL */                case CHAR_NEL:
5213    #ifndef EBCDIC
5214                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
5215                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
5216    #endif  /* Not EBCDIC */
5217                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5218                }                }
5219              break;              break;
# Line 5161  for (;;) Line 5222  for (;;)
5222              switch(c)              switch(c)
5223                {                {
5224                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5225                case 0x0a:      /* LF */                case CHAR_LF:
5226                case 0x0b:      /* VT */                case CHAR_VT:
5227                case 0x0c:      /* FF */                case CHAR_FF:
5228                case 0x0d:      /* CR */                case CHAR_CR:
5229                case 0x85:      /* NEL */                case CHAR_NEL:
5230    #ifndef EBCDIC
5231                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
5232                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
5233    #endif  /* Not EBCDIC */
5234                break;                break;
5235                }                }
5236              break;              break;
# Line 5230  for (;;) Line 5293  for (;;)
5293              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
5294                  eptr >= md->end_subject &&                  eptr >= md->end_subject &&
5295                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
5296                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
5297                  c == NLBLOCK->nl[0])                  c == NLBLOCK->nl[0])
5298                {                {
5299                md->hitend = TRUE;                md->hitend = TRUE;
5300                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5301                }                }
5302              break;              break;
5303    
5304              case OP_ALLANY:              case OP_ALLANY:
5305              case OP_ANYBYTE:              case OP_ANYBYTE:
5306              break;              break;
# Line 5246  for (;;) Line 5309  for (;;)
5309              switch(c)              switch(c)
5310                {                {
5311                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5312                case 0x000d:                case CHAR_CR:
5313                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5314                break;                break;
5315    
5316                case 0x000a:                case CHAR_LF:
5317                break;                break;
5318    
5319                case 0x000b:                case CHAR_VT:
5320                case 0x000c:                case CHAR_FF:
5321                case 0x0085:                case CHAR_NEL:
5322  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5323                case 0x2028:                case 0x2028:
5324                case 0x2029:                case 0x2029:
# Line 5269  for (;;) Line 5332  for (;;)
5332              switch(c)              switch(c)
5333                {                {
5334                default: break;                default: break;
5335                case 0x09:      /* HT */                case CHAR_HT:
5336                case 0x20:      /* SPACE */                case CHAR_SPACE:
5337    #ifndef EBCDIC
5338                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
5339  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5340                case 0x1680:    /* OGHAM SPACE MARK */                case 0x1680:    /* OGHAM SPACE MARK */
# Line 5289  for (;;) Line 5353  for (;;)
5353                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
5354                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5355                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
5356  #endif  #endif  /* COMPILE_PCRE16 */
5357    #endif  /* Not EBCDIC */
5358                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5359                }                }
5360              break;              break;
# Line 5298  for (;;) Line 5363  for (;;)
5363              switch(c)              switch(c)
5364                {                {
5365                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5366                case 0x09:      /* HT */                case CHAR_HT:
5367                case 0x20:      /* SPACE */                case CHAR_SPACE:
5368    #ifndef EBCDIC
5369                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
5370  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5371                case 0x1680:    /* OGHAM SPACE MARK */                case 0x1680:    /* OGHAM SPACE MARK */
# Line 5318  for (;;) Line 5384  for (;;)
5384                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
5385                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5386                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
5387  #endif  #endif  /* COMPILE_PCRE16 */
5388    #endif  /* Not EBCDIC */
5389                break;                break;
5390                }                }
5391              break;              break;
# Line 5327  for (;;) Line 5394  for (;;)
5394              switch(c)              switch(c)
5395                {                {
5396                default: break;                default: break;
5397                case 0x0a:      /* LF */                case CHAR_LF:
5398                case 0x0b:      /* VT */                case CHAR_VT:
5399                case 0x0c:      /* FF */                case CHAR_FF:
5400                case 0x0d:      /* CR */                case CHAR_CR:
5401                case 0x85:      /* NEL */                case CHAR_NEL:
5402  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5403                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
5404                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
# Line 5344  for (;;) Line 5411  for (;;)
5411              switch(c)              switch(c)
5412                {                {
5413                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5414                case 0x0a:      /* LF */                case CHAR_LF:
5415                case 0x0b:      /* VT */                case CHAR_VT:
5416                case 0x0c:      /* FF */                case CHAR_FF:
5417                case 0x0d:      /* CR */                case CHAR_CR:
5418                case 0x85:      /* NEL */                case CHAR_NEL:
5419  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5420                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
5421                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
# Line 5578  for (;;) Line 5645  for (;;)
5645          {          {
5646          for (i = min; i < max; i++)          for (i = min; i < max; i++)
5647            {            {
           int len = 1;  
5648            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
5649              {              {
5650              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5651              break;              break;
5652              }              }
5653            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }            else
5654            if (UCD_CATEGORY(c) == ucp_M) break;              {
5655            eptr += len;              int lgb, rgb;
5656            while (eptr < md->end_subject)              GETCHARINCTEST(c, eptr);
5657              {              lgb = UCD_GRAPHBREAK(c);
5658              len = 1;              while (eptr < md->end_subject)
5659              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }                {
5660              if (UCD_CATEGORY(c) != ucp_M) break;                int len = 1;
5661              eptr += len;                if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5662                  rgb = UCD_GRAPHBREAK(c);
5663                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5664                  lgb = rgb;
5665                  eptr += len;
5666                  }
5667              }              }
5668            CHECK_PARTIAL();            CHECK_PARTIAL();
5669            }            }
5670    
5671          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5641  for (;;) Line 5712  for (;;)
5712                if (md->partial != 0 &&    /* Take care with CRLF partial */                if (md->partial != 0 &&    /* Take care with CRLF partial */
5713                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5714                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5715                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5716                    *eptr == NLBLOCK->nl[0])                    *eptr == NLBLOCK->nl[0])
5717                  {                  {
5718                  md->hitend = TRUE;                  md->hitend = TRUE;
5719                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5720                  }                  }
# Line 5667  for (;;) Line 5738  for (;;)
5738                if (md->partial != 0 &&    /* Take care with CRLF partial */                if (md->partial != 0 &&    /* Take care with CRLF partial */
5739                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5740                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5741                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5742                    *eptr == NLBLOCK->nl[0])                    *eptr == NLBLOCK->nl[0])
5743                  {                  {
5744                  md->hitend = TRUE;                  md->hitend = TRUE;
5745                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5746                  }                  }
# Line 5722  for (;;) Line 5793  for (;;)
5793                break;                break;
5794                }                }
5795              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5796              if (c == 0x000d)              if (c == CHAR_CR)
5797                {                {
5798                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5799                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5800                }                }
5801              else              else
5802                {                {
5803                if (c != 0x000a &&                if (c != CHAR_LF &&
5804                    (md->bsr_anycrlf ||                    (md->bsr_anycrlf ||
5805                     (c != 0x000b && c != 0x000c &&                     (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5806                      c != 0x0085 && c != 0x2028 && c != 0x2029)))  #ifndef EBCDIC
5807                        && c != 0x2028 && c != 0x2029
5808    #endif  /* Not EBCDIC */
5809                        )))
5810                  break;                  break;
5811                eptr += len;                eptr += len;
5812                }                }
# Line 5754  for (;;) Line 5828  for (;;)
5828              switch(c)              switch(c)
5829                {                {
5830                default: gotspace = FALSE; break;                default: gotspace = FALSE; break;
5831                case 0x09:      /* HT */                case CHAR_HT:
5832                case 0x20:      /* SPACE */                case CHAR_SPACE:
5833    #ifndef EBCDIC
5834                case 0xa0:      /* NBSP */                case 0xa0:      /* NBSP */
5835                case 0x1680:    /* OGHAM SPACE MARK */                case 0x1680:    /* OGHAM SPACE MARK */
5836                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */                case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */
# Line 5773  for (;;) Line 5848  for (;;)
5848                case 0x202f:    /* NARROW NO-BREAK SPACE */                case 0x202f:    /* NARROW NO-BREAK SPACE */
5849                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */                case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */
5850                case 0x3000:    /* IDEOGRAPHIC SPACE */                case 0x3000:    /* IDEOGRAPHIC SPACE */
5851    #endif  /* Not EBCDIC */
5852                gotspace = TRUE;                gotspace = TRUE;
5853                break;                break;
5854                }                }
# Line 5796  for (;;) Line 5872  for (;;)
5872              switch(c)              switch(c)
5873                {                {
5874                default: gotspace = FALSE; break;                default: gotspace = FALSE; break;
5875                case 0x0a:      /* LF */                case CHAR_LF:
5876                case 0x0b:      /* VT */                case CHAR_VT:
5877                case 0x0c:      /* FF */                case CHAR_FF:
5878                case 0x0d:      /* CR */                case CHAR_CR:
5879                case 0x85:      /* NEL */                case CHAR_NEL:
5880    #ifndef EBCDIC
5881                case 0x2028:    /* LINE SEPARATOR */                case 0x2028:    /* LINE SEPARATOR */
5882                case 0x2029:    /* PARAGRAPH SEPARATOR */                case 0x2029:    /* PARAGRAPH SEPARATOR */
5883    #endif  /* Not EBCDIC */
5884                gotspace = TRUE;                gotspace = TRUE;
5885                break;                break;
5886                }                }
# Line 5918  for (;;) Line 5996  for (;;)
5996            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5997            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5998            BACKCHAR(eptr);            BACKCHAR(eptr);
5999            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_NL &&
6000                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
6001            }            }
6002          }          }
6003        else        else
# Line 5940  for (;;) Line 6018  for (;;)
6018              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
6019                  eptr + 1 >= md->end_subject &&                  eptr + 1 >= md->end_subject &&
6020                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
6021                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
6022                  *eptr == NLBLOCK->nl[0])                  *eptr == NLBLOCK->nl[0])
6023                {                {
6024                md->hitend = TRUE;                md->hitend = TRUE;
6025                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
6026                }                }
# Line 5970  for (;;) Line 6048  for (;;)
6048                break;                break;
6049                }                }
6050              c = *eptr;              c = *eptr;
6051              if (c == 0x000d)              if (c == CHAR_CR)
6052                {                {
6053                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
6054                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
6055                }                }
6056              else              else
6057                {                {
6058                if (c != 0x000a && (md->bsr_anycrlf ||                if (c != CHAR_LF && (md->bsr_anycrlf ||
6059                  (c != 0x000b && c != 0x000c && c != 0x0085                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
6060  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
6061                  && c != 0x2028 && c != 0x2029                   && c != 0x2028 && c != 0x2029
6062  #endif  #endif
6063                  ))) break;                   ))) break;
6064                eptr++;                eptr++;
6065                }                }
6066              }              }
# Line 5997  for (;;) Line 6075  for (;;)
6075                break;                break;
6076                }                }
6077              c = *eptr;              c = *eptr;
6078              if (c == 0x09 || c == 0x20 || c == 0xa0              if (c == CHAR_HT || c == CHAR_SPACE
6079    #ifndef EBCDIC
6080                  || c == 0xa0
6081  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
6082                || c == 0x1680 || c == 0x180e || (c >= 0x2000 && c <= 0x200A)                || c == 0x1680 || c == 0x180e || (c >= 0x2000 && c <= 0x200A)
6083                || c == 0x202f || c == 0x205f || c == 0x3000                || c == 0x202f || c == 0x205f || c == 0x3000
6084  #endif  #endif  /* COMPILE_PCRE16 */
6085    #endif  /* Not EBCDIC */
6086                ) break;                ) break;
6087              eptr++;              eptr++;
6088              }              }
# Line 6016  for (;;) Line 6097  for (;;)
6097                break;                break;
6098                }                }
6099              c = *eptr;              c = *eptr;
6100              if (c != 0x09 && c != 0x20 && c != 0xa0              if (c != CHAR_HT && c != CHAR_SPACE
6101    #ifndef EBCDIC
6102                  && c != 0xa0
6103  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
6104                && c != 0x1680 && c != 0x180e && (c < 0x2000 || c > 0x200A)                && c != 0x1680 && c != 0x180e && (c < 0x2000 || c > 0x200A)
6105                && c != 0x202f && c != 0x205f && c != 0x3000                && c != 0x202f && c != 0x205f && c != 0x3000
6106  #endif  #endif  /* COMPILE_PCRE16 */
6107    #endif  /* Not EBCDIC */
6108                ) break;                ) break;
6109              eptr++;              eptr++;
6110              }              }
# Line 6035  for (;;) Line 6119  for (;;)
6119                break;                break;
6120                }                }
6121              c = *eptr;              c = *eptr;
6122              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85              if (c == CHAR_LF || c == CHAR_VT || c == CHAR_FF ||
6123                    c == CHAR_CR || c == CHAR_NEL
6124  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
6125                || c == 0x2028 || c == 0x2029                || c == 0x2028 || c == 0x2029
6126  #endif  #endif
# Line 6053  for (;;) Line 6138  for (;;)
6138                break;                break;
6139                }                }
6140              c = *eptr;              c = *eptr;
6141              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85              if (c != CHAR_LF && c != CHAR_VT && c != CHAR_FF &&
6142                    c != CHAR_CR && c != CHAR_NEL
6143  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
6144                && c != 0x2028 && c != 0x2029                && c != 0x2028 && c != 0x2029
6145  #endif  #endif
# Line 6156  for (;;) Line 6242  for (;;)
6242            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
6243            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
6244            eptr--;            eptr--;
6245            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_LF &&
6246                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
6247            }            }
6248          }          }
6249    
# Line 6276  Undefine all the macros that were define Line 6362  Undefine all the macros that were define
6362  ***************************************************************************/  ***************************************************************************/
6363    
6364    
6365    #ifdef NO_RECURSE
6366    /*************************************************
6367    *          Release allocated heap frames         *
6368    *************************************************/
6369    
6370    /* This function releases all the allocated frames. The base frame is on the
6371    machine stack, and so must not be freed.
6372    
6373    Argument: the address of the base frame
6374    Returns:  nothing
6375    */
6376    
6377    static void
6378    release_match_heapframes (heapframe *frame_base)
6379    {
6380    heapframe *nextframe = frame_base->Xnextframe;
6381    while (nextframe != NULL)
6382      {
6383      heapframe *oldframe = nextframe;
6384      nextframe = nextframe->Xnextframe;
6385      (PUBL(stack_free))(oldframe);
6386      }
6387    }
6388    #endif
6389    
6390    
6391  /*************************************************  /*************************************************
6392  *         Execute a Regular Expression           *  *         Execute a Regular Expression           *
# Line 6338  PCRE_PUCHAR req_char_ptr = start_match - Line 6449  PCRE_PUCHAR req_char_ptr = start_match -
6449  const pcre_study_data *study;  const pcre_study_data *study;
6450  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
6451    
6452    #ifdef NO_RECURSE
6453    heapframe frame_zero;
6454    frame_zero.Xprevframe = NULL;            /* Marks the top level */
6455    frame_zero.Xnextframe = NULL;            /* None are allocated yet */
6456    md->match_frames_base = &frame_zero;
6457    #endif
6458    
6459  /* 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
6460  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
6461  compiler gave this error: "unary minus operator applied to unsigned type,  compiler gave this error: "unary minus operator applied to unsigned type,
6462  result still unsigned". Hopefully the cast fixes that. */  result still unsigned". Hopefully the cast fixes that. */
6463    
# Line 6424  if (extra_data != NULL Line 6542  if (extra_data != NULL
6542                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |
6543                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)
6544    {    {
6545    rc = PRIV(jit_exec)(re, extra_data->executable_jit,    rc = PRIV(jit_exec)(re, extra_data, (const pcre_uchar *)subject, length,
6546      (const pcre_uchar *)subject, length, start_offset, options,         start_offset, options, offsets, offsetcount);
6547      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)  
     ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);  
   
6548    /* PCRE_ERROR_NULL means that the selected normal or partial matching    /* PCRE_ERROR_NULL means that the selected normal or partial matching
6549    mode is not compiled. In this case we simply fallback to interpreter. */    mode is not compiled. In this case we simply fallback to interpreter. */
6550    
6551    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;  
     }  
6552    }    }
6553  #endif  #endif
6554    
# Line 6471  if (extra_data != NULL) Line 6583  if (extra_data != NULL)
6583    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
6584      md->callout_data = extra_data->callout_data;      md->callout_data = extra_data->callout_data;
6585    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 */  
6586    }    }
6587    
6588  /* 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 7143  if (rc == MATCH_MATCH || rc == MATCH_ACC
7143      {      {
7144      register int *iptr, *iend;      register int *iptr, *iend;
7145      int resetcount = 2 + re->top_bracket * 2;      int resetcount = 2 + re->top_bracket * 2;
7146      if (resetcount > offsetcount) resetcount = ocount;      if (resetcount > offsetcount) resetcount = offsetcount;
7147      iptr = offsets + md->end_offset_top;      iptr = offsets + md->end_offset_top;
7148      iend = offsets + resetcount;      iend = offsets + resetcount;
7149      while (iptr < iend) *iptr++ = -1;      while (iptr < iend) *iptr++ = -1;
# Line 7053  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 7164  if (rc == MATCH_MATCH || rc == MATCH_ACC
7164    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
7165      *(extra_data->mark) = (pcre_uchar *)md->mark;      *(extra_data->mark) = (pcre_uchar *)md->mark;
7166    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
7167    #ifdef NO_RECURSE
7168      release_match_heapframes(&frame_zero);
7169    #endif
7170    return rc;    return rc;
7171    }    }
7172    
# Line 7070  if (using_temporary_offsets) Line 7184  if (using_temporary_offsets)
7184  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
7185    {    {
7186    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
7187    #ifdef NO_RECURSE
7188      release_match_heapframes(&frame_zero);
7189    #endif
7190    return rc;    return rc;
7191    }    }
7192    
# Line 7099  else Line 7216  else
7216    
7217  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
7218    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;
7219    #ifdef NO_RECURSE
7220      release_match_heapframes(&frame_zero);
7221    #endif
7222  return rc;  return rc;
7223  }  }
7224    

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

  ViewVC Help
Powered by ViewVC 1.1.5