/[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 975 by ph10, Sat Jun 2 11:03:06 2012 UTC
# Line 142  Arguments: Line 142  Arguments:
142    
143  Returns:      >= 0 the number of subject bytes matched  Returns:      >= 0 the number of subject bytes matched
144                -1 no match                -1 no match
145                -2 partial match; always given if at end subject                -2 partial match; always given if at end subject
146  */  */
147    
148  static int  static int
# Line 165  pchars(p, length, FALSE, md); Line 165  pchars(p, length, FALSE, md);
165  printf("\n");  printf("\n");
166  #endif  #endif
167    
168  /* Always fail if reference not set (and not JavaScript compatible - in that  /* Always fail if reference not set (and not JavaScript compatible - in that
169  case the length is passed as zero). */  case the length is passed as zero). */
170    
171  if (length < 0) return -1;  if (length < 0) return -1;
# Line 220  are in UTF-8 mode. */ Line 220  are in UTF-8 mode. */
220    
221  else  else
222    {    {
223    while (length-- > 0)    while (length-- > 0)
224      {      {
225      if (eptr >= md->end_subject) return -2;   /* Partial match */      if (eptr >= md->end_subject) return -2;   /* Partial match */
226      if (*p++ != *eptr++) return -1;      if (*p++ != *eptr++) return -1;
227      }      }
228    }    }
229    
230  return (int)(eptr - eptr_start);  return (int)(eptr - eptr_start);
# Line 317  argument of match(), which never changes Line 317  argument of match(), which never changes
317    
318  #define RMATCH(ra,rb,rc,rd,re,rw)\  #define RMATCH(ra,rb,rc,rd,re,rw)\
319    {\    {\
320    heapframe *newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\    heapframe *newframe = frame->Xnextframe;\
321    if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\    if (newframe == NULL)\
322    frame->Xwhere = rw; \      {\
323        newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
324        if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
325        newframe->Xnextframe = NULL;\
326        frame->Xnextframe = newframe;\
327        }\
328      frame->Xwhere = rw;\
329    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
330    newframe->Xecode = rb;\    newframe->Xecode = rb;\
331    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
# Line 338  argument of match(), which never changes Line 344  argument of match(), which never changes
344    {\    {\
345    heapframe *oldframe = frame;\    heapframe *oldframe = frame;\
346    frame = oldframe->Xprevframe;\    frame = oldframe->Xprevframe;\
   if (oldframe != &frame_zero) (PUBL(stack_free))(oldframe);\  
347    if (frame != NULL)\    if (frame != NULL)\
348      {\      {\
349      rrc = ra;\      rrc = ra;\
# Line 352  argument of match(), which never changes Line 357  argument of match(), which never changes
357    
358  typedef struct heapframe {  typedef struct heapframe {
359    struct heapframe *Xprevframe;    struct heapframe *Xprevframe;
360      struct heapframe *Xnextframe;
361    
362    /* Function arguments that may change */    /* Function arguments that may change */
363    
# Line 498  the top-level on the stack rather than m Line 504  the top-level on the stack rather than m
504  boost in many cases where there is not much "recursion". */  boost in many cases where there is not much "recursion". */
505    
506  #ifdef NO_RECURSE  #ifdef NO_RECURSE
507  heapframe frame_zero;  heapframe *frame = (heapframe *)md->match_frames_base;
 heapframe *frame = &frame_zero;  
 frame->Xprevframe = NULL;            /* Marks the top level */  
508    
509  /* Copy in the original argument variables */  /* Copy in the original argument variables */
510    
# Line 1571  for (;;) Line 1575  for (;;)
1575          mstart = md->start_match_ptr;   /* In case \K reset it */          mstart = md->start_match_ptr;   /* In case \K reset it */
1576          break;          break;
1577          }          }
1578          md->mark = save_mark;
1579    
1580        /* PCRE does not allow THEN to escape beyond an assertion; it is treated        /* A COMMIT failure must fail the entire assertion, without trying any
1581        as NOMATCH. */        subsequent branches. */
1582    
1583          if (rrc == MATCH_COMMIT) RRETURN(MATCH_NOMATCH);
1584    
1585          /* PCRE does not allow THEN to escape beyond an assertion; it
1586          is treated as NOMATCH. */
1587    
1588        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1589        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
       md->mark = save_mark;  
1590        }        }
1591      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1592    
# Line 1785  for (;;) Line 1794  for (;;)
1794            goto RECURSION_MATCHED;        /* Exit loop; end processing */            goto RECURSION_MATCHED;        /* Exit loop; end processing */
1795            }            }
1796    
1797          /* 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
1798          as NOMATCH. */          is treated as NOMATCH. */
1799    
1800          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN &&
1801                     rrc != MATCH_COMMIT)
1802            {            {
1803            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1804            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
# Line 2065  for (;;) Line 2075  for (;;)
2075    
2076      case OP_DOLLM:      case OP_DOLLM:
2077      if (eptr < md->end_subject)      if (eptr < md->end_subject)
2078        {        {
2079        if (!IS_NEWLINE(eptr))        if (!IS_NEWLINE(eptr))
2080          {          {
2081          if (md->partial != 0 &&          if (md->partial != 0 &&
2082              eptr + 1 >= md->end_subject &&              eptr + 1 >= md->end_subject &&
2083              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
2084              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
2085              *eptr == NLBLOCK->nl[0])              *eptr == NLBLOCK->nl[0])
2086            {            {
2087            md->hitend = TRUE;            md->hitend = TRUE;
2088            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2089            }            }
2090          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2091          }          }
2092        }        }
2093      else      else
2094        {        {
# Line 2115  for (;;) Line 2125  for (;;)
2125        if (md->partial != 0 &&        if (md->partial != 0 &&
2126            eptr + 1 >= md->end_subject &&            eptr + 1 >= md->end_subject &&
2127            NLBLOCK->nltype == NLTYPE_FIXED &&            NLBLOCK->nltype == NLTYPE_FIXED &&
2128            NLBLOCK->nllen == 2 &&            NLBLOCK->nllen == 2 &&
2129            *eptr == NLBLOCK->nl[0])            *eptr == NLBLOCK->nl[0])
2130          {          {
2131          md->hitend = TRUE;          md->hitend = TRUE;
2132          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2133          }          }
2134        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2135        }        }
2136    
2137      /* Either at end of string or \n before end. */      /* Either at end of string or \n before end. */
2138    
# Line 2258  for (;;) Line 2268  for (;;)
2268      if (md->partial != 0 &&      if (md->partial != 0 &&
2269          eptr + 1 >= md->end_subject &&          eptr + 1 >= md->end_subject &&
2270          NLBLOCK->nltype == NLTYPE_FIXED &&          NLBLOCK->nltype == NLTYPE_FIXED &&
2271          NLBLOCK->nllen == 2 &&          NLBLOCK->nllen == 2 &&
2272          *eptr == NLBLOCK->nl[0])          *eptr == NLBLOCK->nl[0])
2273        {        {
2274        md->hitend = TRUE;        md->hitend = TRUE;
2275        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2276        }        }
2277    
2278      /* Fall through */      /* Fall through */
2279    
2280      /* Match any single character whatsoever. */      /* Match any single character whatsoever. */
2281    
2282      case OP_ALLANY:      case OP_ALLANY:
2283      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 */
2284        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
# Line 2412  for (;;) Line 2422  for (;;)
2422        if (eptr >= md->end_subject)        if (eptr >= md->end_subject)
2423          {          {
2424          SCHECK_PARTIAL();          SCHECK_PARTIAL();
2425          }          }
2426        else if (*eptr == 0x0a) eptr++;        else if (*eptr == 0x0a) eptr++;
2427        break;        break;
2428    
# Line 2643  for (;;) Line 2653  for (;;)
2653        if (UCD_CATEGORY(c) != ucp_M) break;        if (UCD_CATEGORY(c) != ucp_M) break;
2654        eptr += len;        eptr += len;
2655        }        }
2656      CHECK_PARTIAL();      CHECK_PARTIAL();
2657      ecode++;      ecode++;
2658      break;      break;
2659  #endif  #endif
# Line 2709  for (;;) Line 2719  for (;;)
2719        default:               /* No repeat follows */        default:               /* No repeat follows */
2720        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2721          {          {
2722          if (length == -2) eptr = md->end_subject;   /* Partial match */          if (length == -2) eptr = md->end_subject;   /* Partial match */
2723          CHECK_PARTIAL();          CHECK_PARTIAL();
2724          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2725          }          }
# Line 2735  for (;;) Line 2745  for (;;)
2745        int slength;        int slength;
2746        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2747          {          {
2748          if (slength == -2) eptr = md->end_subject;   /* Partial match */          if (slength == -2) eptr = md->end_subject;   /* Partial match */
2749          CHECK_PARTIAL();          CHECK_PARTIAL();
2750          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2751          }          }
# Line 2759  for (;;) Line 2769  for (;;)
2769          if (fi >= max) RRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2770          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2771            {            {
2772            if (slength == -2) eptr = md->end_subject;   /* Partial match */            if (slength == -2) eptr = md->end_subject;   /* Partial match */
2773            CHECK_PARTIAL();            CHECK_PARTIAL();
2774            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2775            }            }
# Line 2778  for (;;) Line 2788  for (;;)
2788          int slength;          int slength;
2789          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2790            {            {
2791            /* 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
2792            the soft partial matching case. */            the soft partial matching case. */
2793    
2794            if (slength == -2 && md->partial != 0 &&            if (slength == -2 && md->partial != 0 &&
2795                md->end_subject > md->start_used_ptr)                md->end_subject > md->start_used_ptr)
2796              {              {
2797              md->hitend = TRUE;              md->hitend = TRUE;
2798              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2799              }              }
# Line 2791  for (;;) Line 2801  for (;;)
2801            }            }
2802          eptr += slength;          eptr += slength;
2803          }          }
2804    
2805        while (eptr >= pp)        while (eptr >= pp)
2806          {          {
2807          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
# Line 3565  for (;;) Line 3575  for (;;)
3575        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3576        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3577        }        }
3578      ecode++;  #ifdef SUPPORT_UTF
3579      GETCHARINCTEST(c, eptr);      if (utf)
     if (op == OP_NOTI)         /* The caseless case */  
3580        {        {
3581        register unsigned int ch, och;        register unsigned int ch, och;
3582        ch = *ecode++;  
3583  #ifdef COMPILE_PCRE8        ecode++;
3584        /* ch must be < 128 if UTF is enabled. */        GETCHARINC(ch, ecode);
3585        och = md->fcc[ch];        GETCHARINC(c, eptr);
3586  #else  
3587  #ifdef SUPPORT_UTF        if (op == OP_NOT)
3588            {
3589            if (ch == c) RRETURN(MATCH_NOMATCH);
3590            }
3591          else
3592            {
3593  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3594        if (utf && ch > 127)          if (ch > 127)
3595          och = UCD_OTHERCASE(ch);            och = UCD_OTHERCASE(ch);
3596  #else  #else
3597        if (utf && ch > 127)          if (ch > 127)
3598          och = ch;            och = ch;
3599  #endif /* SUPPORT_UCP */  #endif /* SUPPORT_UCP */
3600        else          else
3601  #endif /* SUPPORT_UTF */            och = TABLE_GET(ch, md->fcc, ch);
3602          och = TABLE_GET(ch, md->fcc, ch);          if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
3603  #endif /* COMPILE_PCRE8 */          }
       if (ch == c || och == c) RRETURN(MATCH_NOMATCH);  
3604        }        }
3605      else    /* Caseful */      else
3606    #endif
3607        {        {
3608        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        register unsigned int ch = ecode[1];
3609          c = *eptr++;
3610          if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3611            RRETURN(MATCH_NOMATCH);
3612          ecode += 2;
3613        }        }
3614      break;      break;
3615    
# Line 3671  for (;;) Line 3689  for (;;)
3689      /* Common code for all repeated single-byte matches. */      /* Common code for all repeated single-byte matches. */
3690    
3691      REPEATNOTCHAR:      REPEATNOTCHAR:
3692      fc = *ecode++;      GETCHARINCTEST(fc, ecode);
3693    
3694      /* The code is duplicated for the caseless and caseful cases, for speed,      /* The code is duplicated for the caseless and caseful cases, for speed,
3695      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 3686  for (;;) Line 3704  for (;;)
3704    
3705      if (op >= OP_NOTSTARI)     /* Caseless */      if (op >= OP_NOTSTARI)     /* Caseless */
3706        {        {
 #ifdef COMPILE_PCRE8  
       /* fc must be < 128 if UTF is enabled. */  
       foc = md->fcc[fc];  
 #else  
3707  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3708  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3709        if (utf && fc > 127)        if (utf && fc > 127)
# Line 3701  for (;;) Line 3715  for (;;)
3715        else        else
3716  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
3717          foc = TABLE_GET(fc, md->fcc, fc);          foc = TABLE_GET(fc, md->fcc, fc);
 #endif /* COMPILE_PCRE8 */  
3718    
3719  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3720        if (utf)        if (utf)
# Line 3715  for (;;) Line 3728  for (;;)
3728              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3729              }              }
3730            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3731            if (fc == d || (unsigned int) foc == d) RRETURN(MATCH_NOMATCH);            if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3732            }            }
3733          }          }
3734        else        else
# Line 4225  for (;;) Line 4238  for (;;)
4238              if (UCD_CATEGORY(c) != ucp_M) break;              if (UCD_CATEGORY(c) != ucp_M) break;
4239              eptr += len;              eptr += len;
4240              }              }
4241            CHECK_PARTIAL();            CHECK_PARTIAL();
4242            }            }
4243          }          }
4244    
# Line 4249  for (;;) Line 4262  for (;;)
4262            if (md->partial != 0 &&            if (md->partial != 0 &&
4263                eptr + 1 >= md->end_subject &&                eptr + 1 >= md->end_subject &&
4264                NLBLOCK->nltype == NLTYPE_FIXED &&                NLBLOCK->nltype == NLTYPE_FIXED &&
4265                NLBLOCK->nllen == 2 &&                NLBLOCK->nllen == 2 &&
4266                *eptr == NLBLOCK->nl[0])                *eptr == NLBLOCK->nl[0])
4267              {              {
4268              md->hitend = TRUE;              md->hitend = TRUE;
4269              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4270              }              }
# Line 4542  for (;;) Line 4555  for (;;)
4555            if (md->partial != 0 &&            if (md->partial != 0 &&
4556                eptr + 1 >= md->end_subject &&                eptr + 1 >= md->end_subject &&
4557                NLBLOCK->nltype == NLTYPE_FIXED &&                NLBLOCK->nltype == NLTYPE_FIXED &&
4558                NLBLOCK->nllen == 2 &&                NLBLOCK->nllen == 2 &&
4559                *eptr == NLBLOCK->nl[0])                *eptr == NLBLOCK->nl[0])
4560              {              {
4561              md->hitend = TRUE;              md->hitend = TRUE;
4562              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4563              }              }
# Line 5028  for (;;) Line 5041  for (;;)
5041              if (UCD_CATEGORY(c) != ucp_M) break;              if (UCD_CATEGORY(c) != ucp_M) break;
5042              eptr += len;              eptr += len;
5043              }              }
5044            CHECK_PARTIAL();            CHECK_PARTIAL();
5045            }            }
5046          }          }
5047        else        else
# Line 5056  for (;;) Line 5069  for (;;)
5069              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
5070                  eptr >= md->end_subject &&                  eptr >= md->end_subject &&
5071                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
5072                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
5073                  c == NLBLOCK->nl[0])                  c == NLBLOCK->nl[0])
5074                {                {
5075                md->hitend = TRUE;                md->hitend = TRUE;
5076                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5077                }                }
5078              break;              break;
5079    
5080              case OP_ALLANY:              case OP_ALLANY:
5081              case OP_ANYBYTE:              case OP_ANYBYTE:
5082              break;              break;
# Line 5230  for (;;) Line 5243  for (;;)
5243              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
5244                  eptr >= md->end_subject &&                  eptr >= md->end_subject &&
5245                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
5246                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
5247                  c == NLBLOCK->nl[0])                  c == NLBLOCK->nl[0])
5248                {                {
5249                md->hitend = TRUE;                md->hitend = TRUE;
5250                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5251                }                }
5252              break;              break;
5253    
5254              case OP_ALLANY:              case OP_ALLANY:
5255              case OP_ANYBYTE:              case OP_ANYBYTE:
5256              break;              break;
# Line 5594  for (;;) Line 5607  for (;;)
5607              if (UCD_CATEGORY(c) != ucp_M) break;              if (UCD_CATEGORY(c) != ucp_M) break;
5608              eptr += len;              eptr += len;
5609              }              }
5610            CHECK_PARTIAL();            CHECK_PARTIAL();
5611            }            }
5612    
5613          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5641  for (;;) Line 5654  for (;;)
5654                if (md->partial != 0 &&    /* Take care with CRLF partial */                if (md->partial != 0 &&    /* Take care with CRLF partial */
5655                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5656                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5657                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5658                    *eptr == NLBLOCK->nl[0])                    *eptr == NLBLOCK->nl[0])
5659                  {                  {
5660                  md->hitend = TRUE;                  md->hitend = TRUE;
5661                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5662                  }                  }
# Line 5667  for (;;) Line 5680  for (;;)
5680                if (md->partial != 0 &&    /* Take care with CRLF partial */                if (md->partial != 0 &&    /* Take care with CRLF partial */
5681                    eptr + 1 >= md->end_subject &&                    eptr + 1 >= md->end_subject &&
5682                    NLBLOCK->nltype == NLTYPE_FIXED &&                    NLBLOCK->nltype == NLTYPE_FIXED &&
5683                    NLBLOCK->nllen == 2 &&                    NLBLOCK->nllen == 2 &&
5684                    *eptr == NLBLOCK->nl[0])                    *eptr == NLBLOCK->nl[0])
5685                  {                  {
5686                  md->hitend = TRUE;                  md->hitend = TRUE;
5687                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5688                  }                  }
# Line 5940  for (;;) Line 5953  for (;;)
5953              if (md->partial != 0 &&    /* Take care with CRLF partial */              if (md->partial != 0 &&    /* Take care with CRLF partial */
5954                  eptr + 1 >= md->end_subject &&                  eptr + 1 >= md->end_subject &&
5955                  NLBLOCK->nltype == NLTYPE_FIXED &&                  NLBLOCK->nltype == NLTYPE_FIXED &&
5956                  NLBLOCK->nllen == 2 &&                  NLBLOCK->nllen == 2 &&
5957                  *eptr == NLBLOCK->nl[0])                  *eptr == NLBLOCK->nl[0])
5958                {                {
5959                md->hitend = TRUE;                md->hitend = TRUE;
5960                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5961                }                }
# Line 6276  Undefine all the macros that were define Line 6289  Undefine all the macros that were define
6289  ***************************************************************************/  ***************************************************************************/
6290    
6291    
6292    #ifdef NO_RECURSE
6293    /*************************************************
6294    *          Release allocated heap frames         *
6295    *************************************************/
6296    
6297    /* This function releases all the allocated frames. The base frame is on the
6298    machine stack, and so must not be freed.
6299    
6300    Argument: the address of the base frame
6301    Returns:  nothing
6302    */
6303    
6304    static void
6305    release_match_heapframes (heapframe *frame_base)
6306    {
6307    heapframe *nextframe = frame_base->Xnextframe;
6308    while (nextframe != NULL)
6309      {
6310      heapframe *oldframe = nextframe;
6311      nextframe = nextframe->Xnextframe;
6312      (PUBL(stack_free))(oldframe);
6313      }
6314    }
6315    #endif
6316    
6317    
6318  /*************************************************  /*************************************************
6319  *         Execute a Regular Expression           *  *         Execute a Regular Expression           *
# Line 6338  PCRE_PUCHAR req_char_ptr = start_match - Line 6376  PCRE_PUCHAR req_char_ptr = start_match -
6376  const pcre_study_data *study;  const pcre_study_data *study;
6377  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
6378    
6379    #ifdef NO_RECURSE
6380    heapframe frame_zero;
6381    frame_zero.Xprevframe = NULL;            /* Marks the top level */
6382    frame_zero.Xnextframe = NULL;            /* None are allocated yet */
6383    md->match_frames_base = &frame_zero;
6384    #endif
6385    
6386  /* 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
6387  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
6388  compiler gave this error: "unary minus operator applied to unsigned type,  compiler gave this error: "unary minus operator applied to unsigned type,
6389  result still unsigned". Hopefully the cast fixes that. */  result still unsigned". Hopefully the cast fixes that. */
6390    
# Line 6424  if (extra_data != NULL Line 6469  if (extra_data != NULL
6469                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |
6470                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)
6471    {    {
6472    rc = PRIV(jit_exec)(re, extra_data->executable_jit,    rc = PRIV(jit_exec)(re, extra_data, (const pcre_uchar *)subject, length,
6473      (const pcre_uchar *)subject, length, start_offset, options,         start_offset, options, offsets, offsetcount);
6474      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)  
     ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);  
   
6475    /* PCRE_ERROR_NULL means that the selected normal or partial matching    /* PCRE_ERROR_NULL means that the selected normal or partial matching
6476    mode is not compiled. In this case we simply fallback to interpreter. */    mode is not compiled. In this case we simply fallback to interpreter. */
6477    
6478    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;  
     }  
6479    }    }
6480  #endif  #endif
6481    
# Line 6471  if (extra_data != NULL) Line 6510  if (extra_data != NULL)
6510    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
6511      md->callout_data = extra_data->callout_data;      md->callout_data = extra_data->callout_data;
6512    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 */  
6513    }    }
6514    
6515  /* 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 7070  if (rc == MATCH_MATCH || rc == MATCH_ACC
7070      {      {
7071      register int *iptr, *iend;      register int *iptr, *iend;
7072      int resetcount = 2 + re->top_bracket * 2;      int resetcount = 2 + re->top_bracket * 2;
7073      if (resetcount > offsetcount) resetcount = ocount;      if (resetcount > offsetcount) resetcount = offsetcount;
7074      iptr = offsets + md->end_offset_top;      iptr = offsets + md->end_offset_top;
7075      iend = offsets + resetcount;      iend = offsets + resetcount;
7076      while (iptr < iend) *iptr++ = -1;      while (iptr < iend) *iptr++ = -1;
# Line 7053  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 7091  if (rc == MATCH_MATCH || rc == MATCH_ACC
7091    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
7092      *(extra_data->mark) = (pcre_uchar *)md->mark;      *(extra_data->mark) = (pcre_uchar *)md->mark;
7093    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
7094    #ifdef NO_RECURSE
7095      release_match_heapframes(&frame_zero);
7096    #endif
7097    return rc;    return rc;
7098    }    }
7099    
# Line 7070  if (using_temporary_offsets) Line 7111  if (using_temporary_offsets)
7111  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
7112    {    {
7113    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
7114    #ifdef NO_RECURSE
7115      release_match_heapframes(&frame_zero);
7116    #endif
7117    return rc;    return rc;
7118    }    }
7119    
# Line 7099  else Line 7143  else
7143    
7144  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
7145    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;
7146    #ifdef NO_RECURSE
7147      release_match_heapframes(&frame_zero);
7148    #endif
7149  return rc;  return rc;
7150  }  }
7151    

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

  ViewVC Help
Powered by ViewVC 1.1.5