/[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 916 by ph10, Wed Feb 15 09:50:53 2012 UTC revision 933 by ph10, Sat Feb 25 12:18:23 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 2065  for (;;) Line 2069  for (;;)
2069    
2070      case OP_DOLLM:      case OP_DOLLM:
2071      if (eptr < md->end_subject)      if (eptr < md->end_subject)
2072        {        {
2073        if (!IS_NEWLINE(eptr))        if (!IS_NEWLINE(eptr))
2074          {          {
2075          if (eptr + 1 >= md->end_subject &&          if (md->partial != 0 &&
2076              md->partial != 0 &&              eptr + 1 >= md->end_subject &&
2077              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
2078              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
2079              *eptr == NLBLOCK->nl[0])              *eptr == NLBLOCK->nl[0])
2080            {            {
2081            md->hitend = TRUE;            md->hitend = TRUE;
2082            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2083            }            }
2084          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2085          }          }
2086        }        }
2087      else      else
2088        {        {
# Line 2112  for (;;) Line 2116  for (;;)
2116      if (eptr < md->end_subject &&      if (eptr < md->end_subject &&
2117          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
2118        {        {
2119        if (eptr + 1 >= md->end_subject &&        if (md->partial != 0 &&
2120            md->partial != 0 &&            eptr + 1 >= md->end_subject &&
2121            NLBLOCK->nltype == NLTYPE_FIXED &&            NLBLOCK->nltype == NLTYPE_FIXED &&
2122            NLBLOCK->nllen == 2 &&            NLBLOCK->nllen == 2 &&
2123            *eptr == NLBLOCK->nl[0])            *eptr == NLBLOCK->nl[0])
2124          {          {
2125          md->hitend = TRUE;          md->hitend = TRUE;
2126          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2127          }          }
2128        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2129        }        }
2130    
2131      /* Either at end of string or \n before end. */      /* Either at end of string or \n before end. */
2132    
# Line 2250  for (;;) Line 2254  for (;;)
2254        }        }
2255      break;      break;
2256    
2257      /* Match a single character type; inline for speed */      /* Match any single character type except newline; have to take care with
2258        CRLF newlines and partial matching. */
2259    
2260      case OP_ANY:      case OP_ANY:
2261      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
2262        if (md->partial != 0 &&
2263            eptr + 1 >= md->end_subject &&
2264            NLBLOCK->nltype == NLTYPE_FIXED &&
2265            NLBLOCK->nllen == 2 &&
2266            *eptr == NLBLOCK->nl[0])
2267          {
2268          md->hitend = TRUE;
2269          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2270          }
2271    
2272      /* Fall through */      /* Fall through */
2273    
2274        /* Match any single character whatsoever. */
2275    
2276      case OP_ALLANY:      case OP_ALLANY:
2277      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 */
2278        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
# Line 2399  for (;;) Line 2416  for (;;)
2416        if (eptr >= md->end_subject)        if (eptr >= md->end_subject)
2417          {          {
2418          SCHECK_PARTIAL();          SCHECK_PARTIAL();
2419          }          }
2420        else if (*eptr == 0x0a) eptr++;        else if (*eptr == 0x0a) eptr++;
2421        break;        break;
2422    
# Line 2630  for (;;) Line 2647  for (;;)
2647        if (UCD_CATEGORY(c) != ucp_M) break;        if (UCD_CATEGORY(c) != ucp_M) break;
2648        eptr += len;        eptr += len;
2649        }        }
2650      CHECK_PARTIAL();      CHECK_PARTIAL();
2651      ecode++;      ecode++;
2652      break;      break;
2653  #endif  #endif
# Line 2696  for (;;) Line 2713  for (;;)
2713        default:               /* No repeat follows */        default:               /* No repeat follows */
2714        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2715          {          {
2716          if (length == -2) eptr = md->end_subject;   /* Partial match */          if (length == -2) eptr = md->end_subject;   /* Partial match */
2717          CHECK_PARTIAL();          CHECK_PARTIAL();
2718          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2719          }          }
# Line 2722  for (;;) Line 2739  for (;;)
2739        int slength;        int slength;
2740        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2741          {          {
2742          if (slength == -2) eptr = md->end_subject;   /* Partial match */          if (slength == -2) eptr = md->end_subject;   /* Partial match */
2743          CHECK_PARTIAL();          CHECK_PARTIAL();
2744          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2745          }          }
# Line 2746  for (;;) Line 2763  for (;;)
2763          if (fi >= max) RRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2764          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2765            {            {
2766            if (slength == -2) eptr = md->end_subject;   /* Partial match */            if (slength == -2) eptr = md->end_subject;   /* Partial match */
2767            CHECK_PARTIAL();            CHECK_PARTIAL();
2768            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2769            }            }
# Line 2765  for (;;) Line 2782  for (;;)
2782          int slength;          int slength;
2783          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2784            {            {
2785            /* 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
2786            the soft partial matching case. */            the soft partial matching case. */
2787    
2788            if (slength == -2 && md->partial != 0 &&            if (slength == -2 && md->partial != 0 &&
2789                md->end_subject > md->start_used_ptr)                md->end_subject > md->start_used_ptr)
2790              {              {
2791              md->hitend = TRUE;              md->hitend = TRUE;
2792              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2793              }              }
# Line 2778  for (;;) Line 2795  for (;;)
2795            }            }
2796          eptr += slength;          eptr += slength;
2797          }          }
2798    
2799        while (eptr >= pp)        while (eptr >= pp)
2800          {          {
2801          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
# Line 3552  for (;;) Line 3569  for (;;)
3569        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3570        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3571        }        }
3572      ecode++;  #ifdef SUPPORT_UTF
3573      GETCHARINCTEST(c, eptr);      if (utf)
     if (op == OP_NOTI)         /* The caseless case */  
3574        {        {
3575        register unsigned int ch, och;        register unsigned int ch, och;
3576        ch = *ecode++;  
3577  #ifdef COMPILE_PCRE8        ecode++;
3578        /* ch must be < 128 if UTF is enabled. */        GETCHARINC(ch, ecode);
3579        och = md->fcc[ch];        GETCHARINC(c, eptr);
3580  #else  
3581  #ifdef SUPPORT_UTF        if (op == OP_NOT)
3582            {
3583            if (ch == c) RRETURN(MATCH_NOMATCH);
3584            }
3585          else
3586            {
3587  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3588        if (utf && ch > 127)          if (ch > 127)
3589          och = UCD_OTHERCASE(ch);            och = UCD_OTHERCASE(ch);
3590  #else  #else
3591        if (utf && ch > 127)          if (ch > 127)
3592          och = ch;            och = ch;
3593  #endif /* SUPPORT_UCP */  #endif /* SUPPORT_UCP */
3594        else          else
3595  #endif /* SUPPORT_UTF */            och = TABLE_GET(ch, md->fcc, ch);
3596          och = TABLE_GET(ch, md->fcc, ch);          if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
3597  #endif /* COMPILE_PCRE8 */          }
       if (ch == c || och == c) RRETURN(MATCH_NOMATCH);  
3598        }        }
3599      else    /* Caseful */      else
3600    #endif
3601        {        {
3602        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        register unsigned int ch = ecode[1];
3603          c = *eptr++;
3604          if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3605            RRETURN(MATCH_NOMATCH);
3606          ecode += 2;
3607        }        }
3608      break;      break;
3609    
# Line 3658  for (;;) Line 3683  for (;;)
3683      /* Common code for all repeated single-byte matches. */      /* Common code for all repeated single-byte matches. */
3684    
3685      REPEATNOTCHAR:      REPEATNOTCHAR:
3686      fc = *ecode++;      GETCHARINCTEST(fc, ecode);
3687    
3688      /* The code is duplicated for the caseless and caseful cases, for speed,      /* The code is duplicated for the caseless and caseful cases, for speed,
3689      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 3673  for (;;) Line 3698  for (;;)
3698    
3699      if (op >= OP_NOTSTARI)     /* Caseless */      if (op >= OP_NOTSTARI)     /* Caseless */
3700        {        {
 #ifdef COMPILE_PCRE8  
       /* fc must be < 128 if UTF is enabled. */  
       foc = md->fcc[fc];  
 #else  
3701  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3702  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3703        if (utf && fc > 127)        if (utf && fc > 127)
# Line 3688  for (;;) Line 3709  for (;;)
3709        else        else
3710  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
3711          foc = TABLE_GET(fc, md->fcc, fc);          foc = TABLE_GET(fc, md->fcc, fc);
 #endif /* COMPILE_PCRE8 */  
3712    
3713  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3714        if (utf)        if (utf)
# Line 3702  for (;;) Line 3722  for (;;)
3722              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3723              }              }
3724            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3725            if (fc == d || (unsigned int) foc == d) RRETURN(MATCH_NOMATCH);            if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3726            }            }
3727          }          }
3728        else        else
# Line 4212  for (;;) Line 4232  for (;;)
4232              if (UCD_CATEGORY(c) != ucp_M) break;              if (UCD_CATEGORY(c) != ucp_M) break;
4233              eptr += len;              eptr += len;
4234              }              }
4235            CHECK_PARTIAL();            CHECK_PARTIAL();
4236            }            }
4237          }          }
4238    
# Line 4233  for (;;) Line 4253  for (;;)
4253              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4254              }              }
4255            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4256              if (md->partial != 0 &&
4257                  eptr + 1 >= md->end_subject &&
4258                  NLBLOCK->nltype == NLTYPE_FIXED &&
4259                  NLBLOCK->nllen == 2 &&
4260                  *eptr == NLBLOCK->nl[0])
4261                {
4262                md->hitend = TRUE;
4263                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4264                }
4265            eptr++;            eptr++;
4266            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4267            }            }
# Line 4517  for (;;) Line 4546  for (;;)
4546              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4547              }              }
4548            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4549              if (md->partial != 0 &&
4550                  eptr + 1 >= md->end_subject &&
4551                  NLBLOCK->nltype == NLTYPE_FIXED &&
4552                  NLBLOCK->nllen == 2 &&
4553                  *eptr == NLBLOCK->nl[0])
4554                {
4555                md->hitend = TRUE;
4556                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4557                }
4558            eptr++;            eptr++;
4559            }            }
4560          break;          break;
# Line 4997  for (;;) Line 5035  for (;;)
5035              if (UCD_CATEGORY(c) != ucp_M) break;              if (UCD_CATEGORY(c) != ucp_M) break;
5036              eptr += len;              eptr += len;
5037              }              }
5038            CHECK_PARTIAL();            CHECK_PARTIAL();
5039            }            }
5040          }          }
5041        else        else
# Line 5021  for (;;) Line 5059  for (;;)
5059            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
5060            switch(ctype)            switch(ctype)
5061              {              {
5062              case OP_ANY:        /* This is the non-NL case */              case OP_ANY:               /* This is the non-NL case */
5063                if (md->partial != 0 &&    /* Take care with CRLF partial */
5064                    eptr >= md->end_subject &&
5065                    NLBLOCK->nltype == NLTYPE_FIXED &&
5066                    NLBLOCK->nllen == 2 &&
5067                    c == NLBLOCK->nl[0])
5068                  {
5069                  md->hitend = TRUE;
5070                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5071                  }
5072                break;
5073    
5074              case OP_ALLANY:              case OP_ALLANY:
5075              case OP_ANYBYTE:              case OP_ANYBYTE:
5076              break;              break;
# Line 5184  for (;;) Line 5233  for (;;)
5233            c = *eptr++;            c = *eptr++;
5234            switch(ctype)            switch(ctype)
5235              {              {
5236              case OP_ANY:     /* This is the non-NL case */              case OP_ANY:               /* This is the non-NL case */
5237                if (md->partial != 0 &&    /* Take care with CRLF partial */
5238                    eptr >= md->end_subject &&
5239                    NLBLOCK->nltype == NLTYPE_FIXED &&
5240                    NLBLOCK->nllen == 2 &&
5241                    c == NLBLOCK->nl[0])
5242                  {
5243                  md->hitend = TRUE;
5244                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5245                  }
5246                break;
5247    
5248              case OP_ALLANY:              case OP_ALLANY:
5249              case OP_ANYBYTE:              case OP_ANYBYTE:
5250              break;              break;
# Line 5541  for (;;) Line 5601  for (;;)
5601              if (UCD_CATEGORY(c) != ucp_M) break;              if (UCD_CATEGORY(c) != ucp_M) break;
5602              eptr += len;              eptr += len;
5603              }              }
5604            CHECK_PARTIAL();            CHECK_PARTIAL();
5605            }            }
5606    
5607          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5585  for (;;) Line 5645  for (;;)
5645                  break;                  break;
5646                  }                  }
5647                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
5648                  if (md->partial != 0 &&    /* Take care with CRLF partial */
5649                      eptr + 1 >= md->end_subject &&
5650                      NLBLOCK->nltype == NLTYPE_FIXED &&
5651                      NLBLOCK->nllen == 2 &&
5652                      *eptr == NLBLOCK->nl[0])
5653                    {
5654                    md->hitend = TRUE;
5655                    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5656                    }
5657                eptr++;                eptr++;
5658                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5659                }                }
# Line 5602  for (;;) Line 5671  for (;;)
5671                  break;                  break;
5672                  }                  }
5673                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
5674                  if (md->partial != 0 &&    /* Take care with CRLF partial */
5675                      eptr + 1 >= md->end_subject &&
5676                      NLBLOCK->nltype == NLTYPE_FIXED &&
5677                      NLBLOCK->nllen == 2 &&
5678                      *eptr == NLBLOCK->nl[0])
5679                    {
5680                    md->hitend = TRUE;
5681                    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5682                    }
5683                eptr++;                eptr++;
5684                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5685                }                }
# Line 5866  for (;;) Line 5944  for (;;)
5944                break;                break;
5945                }                }
5946              if (IS_NEWLINE(eptr)) break;              if (IS_NEWLINE(eptr)) break;
5947                if (md->partial != 0 &&    /* Take care with CRLF partial */
5948                    eptr + 1 >= md->end_subject &&
5949                    NLBLOCK->nltype == NLTYPE_FIXED &&
5950                    NLBLOCK->nllen == 2 &&
5951                    *eptr == NLBLOCK->nl[0])
5952                  {
5953                  md->hitend = TRUE;
5954                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5955                  }
5956              eptr++;              eptr++;
5957              }              }
5958            break;            break;
# Line 6196  Undefine all the macros that were define Line 6283  Undefine all the macros that were define
6283  ***************************************************************************/  ***************************************************************************/
6284    
6285    
6286    #ifdef NO_RECURSE
6287    /*************************************************
6288    *          Release allocated heap frames         *
6289    *************************************************/
6290    
6291    /* This function releases all the allocated frames. The base frame is on the
6292    machine stack, and so must not be freed.
6293    
6294    Argument: the address of the base frame
6295    Returns:  nothing
6296    */
6297    
6298    static void
6299    release_match_heapframes (heapframe *frame_base)
6300    {
6301    heapframe *nextframe = frame_base->Xnextframe;
6302    while (nextframe != NULL)
6303      {
6304      heapframe *oldframe = nextframe;
6305      nextframe = nextframe->Xnextframe;
6306      (PUBL(stack_free))(oldframe);
6307      }
6308    }
6309    #endif
6310    
6311    
6312  /*************************************************  /*************************************************
6313  *         Execute a Regular Expression           *  *         Execute a Regular Expression           *
# Line 6258  PCRE_PUCHAR req_char_ptr = start_match - Line 6370  PCRE_PUCHAR req_char_ptr = start_match -
6370  const pcre_study_data *study;  const pcre_study_data *study;
6371  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
6372    
6373    #ifdef NO_RECURSE
6374    heapframe frame_zero;
6375    frame_zero.Xprevframe = NULL;            /* Marks the top level */
6376    frame_zero.Xnextframe = NULL;            /* None are allocated yet */
6377    md->match_frames_base = &frame_zero;
6378    #endif
6379    
6380  /* 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
6381  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
6382  compiler gave this error: "unary minus operator applied to unsigned type,  compiler gave this error: "unary minus operator applied to unsigned type,
6383  result still unsigned". Hopefully the cast fixes that. */  result still unsigned". Hopefully the cast fixes that. */
6384    
# Line 6347  if (extra_data != NULL Line 6466  if (extra_data != NULL
6466    rc = PRIV(jit_exec)(re, extra_data->executable_jit,    rc = PRIV(jit_exec)(re, extra_data->executable_jit,
6467      (const pcre_uchar *)subject, length, start_offset, options,      (const pcre_uchar *)subject, length, start_offset, options,
6468      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)
6469      ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);      ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount,
6470        ((extra_data->flags & PCRE_EXTRA_MARK) != 0) ? extra_data->mark : NULL);
6471    
6472    /* PCRE_ERROR_NULL means that the selected normal or partial matching    /* PCRE_ERROR_NULL means that the selected normal or partial matching
6473    mode is not compiled. In this case we simply fallback to interpreter. */    mode is not compiled. In this case we simply fallback to interpreter. */
6474    
6475    if (rc != PCRE_ERROR_NULL) return rc;    if (rc != PCRE_ERROR_NULL) return rc;
6476    }    }
6477  #endif  #endif
# Line 6968  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 7088  if (rc == MATCH_MATCH || rc == MATCH_ACC
7088    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
7089      *(extra_data->mark) = (pcre_uchar *)md->mark;      *(extra_data->mark) = (pcre_uchar *)md->mark;
7090    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
7091    #ifdef NO_RECURSE
7092      release_match_heapframes(&frame_zero);
7093    #endif
7094    return rc;    return rc;
7095    }    }
7096    
# Line 6985  if (using_temporary_offsets) Line 7108  if (using_temporary_offsets)
7108  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
7109    {    {
7110    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
7111    #ifdef NO_RECURSE
7112      release_match_heapframes(&frame_zero);
7113    #endif
7114    return rc;    return rc;
7115    }    }
7116    
# Line 7014  else Line 7140  else
7140    
7141  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
7142    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;
7143    #ifdef NO_RECURSE
7144      release_match_heapframes(&frame_zero);
7145    #endif
7146  return rc;  return rc;
7147  }  }
7148    

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

  ViewVC Help
Powered by ViewVC 1.1.5