/[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 929 by zherczeg, Fri Feb 24 11:07:47 2012 UTC
# Line 2068  for (;;) Line 2068  for (;;)
2068        {        {
2069        if (!IS_NEWLINE(eptr))        if (!IS_NEWLINE(eptr))
2070          {          {
2071          if (eptr + 1 >= md->end_subject &&          if (md->partial != 0 &&
2072              md->partial != 0 &&              eptr + 1 >= md->end_subject &&
2073              NLBLOCK->nltype == NLTYPE_FIXED &&              NLBLOCK->nltype == NLTYPE_FIXED &&
2074              NLBLOCK->nllen == 2 &&              NLBLOCK->nllen == 2 &&
2075              *eptr == NLBLOCK->nl[0])              *eptr == NLBLOCK->nl[0])
# Line 2112  for (;;) Line 2112  for (;;)
2112      if (eptr < md->end_subject &&      if (eptr < md->end_subject &&
2113          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
2114        {        {
2115        if (eptr + 1 >= md->end_subject &&        if (md->partial != 0 &&
2116            md->partial != 0 &&            eptr + 1 >= md->end_subject &&
2117            NLBLOCK->nltype == NLTYPE_FIXED &&            NLBLOCK->nltype == NLTYPE_FIXED &&
2118            NLBLOCK->nllen == 2 &&            NLBLOCK->nllen == 2 &&
2119            *eptr == NLBLOCK->nl[0])            *eptr == NLBLOCK->nl[0])
# Line 2250  for (;;) Line 2250  for (;;)
2250        }        }
2251      break;      break;
2252    
2253      /* Match a single character type; inline for speed */      /* Match any single character type except newline; have to take care with
2254        CRLF newlines and partial matching. */
2255    
2256      case OP_ANY:      case OP_ANY:
2257      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
2258        if (md->partial != 0 &&
2259            eptr + 1 >= md->end_subject &&
2260            NLBLOCK->nltype == NLTYPE_FIXED &&
2261            NLBLOCK->nllen == 2 &&
2262            *eptr == NLBLOCK->nl[0])
2263          {
2264          md->hitend = TRUE;
2265          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2266          }
2267    
2268      /* Fall through */      /* Fall through */
2269    
2270        /* Match any single character whatsoever. */
2271    
2272      case OP_ALLANY:      case OP_ALLANY:
2273      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 */
2274        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
# Line 3552  for (;;) Line 3565  for (;;)
3565        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3566        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3567        }        }
3568      ecode++;  #ifdef SUPPORT_UTF
3569      GETCHARINCTEST(c, eptr);      if (utf)
     if (op == OP_NOTI)         /* The caseless case */  
3570        {        {
3571        register unsigned int ch, och;        register unsigned int ch, och;
3572        ch = *ecode++;  
3573  #ifdef COMPILE_PCRE8        ecode++;
3574        /* ch must be < 128 if UTF is enabled. */        GETCHARINC(ch, ecode);
3575        och = md->fcc[ch];        GETCHARINC(c, eptr);
3576  #else  
3577  #ifdef SUPPORT_UTF        if (op == OP_NOT)
3578            {
3579            if (ch == c) RRETURN(MATCH_NOMATCH);
3580            }
3581          else
3582            {
3583  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3584        if (utf && ch > 127)          if (ch > 127)
3585          och = UCD_OTHERCASE(ch);            och = UCD_OTHERCASE(ch);
3586  #else  #else
3587        if (utf && ch > 127)          if (ch > 127)
3588          och = ch;            och = ch;
3589  #endif /* SUPPORT_UCP */  #endif /* SUPPORT_UCP */
3590        else          else
3591  #endif /* SUPPORT_UTF */            och = TABLE_GET(ch, md->fcc, ch);
3592          och = TABLE_GET(ch, md->fcc, ch);          if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
3593  #endif /* COMPILE_PCRE8 */          }
       if (ch == c || och == c) RRETURN(MATCH_NOMATCH);  
3594        }        }
3595      else    /* Caseful */      else
3596    #endif
3597        {        {
3598        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        register unsigned int ch = ecode[1];
3599          c = *eptr++;
3600          if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3601            RRETURN(MATCH_NOMATCH);
3602          ecode += 2;
3603        }        }
3604      break;      break;
3605    
# Line 3658  for (;;) Line 3679  for (;;)
3679      /* Common code for all repeated single-byte matches. */      /* Common code for all repeated single-byte matches. */
3680    
3681      REPEATNOTCHAR:      REPEATNOTCHAR:
3682      fc = *ecode++;      GETCHARINCTEST(fc, ecode);
3683    
3684      /* The code is duplicated for the caseless and caseful cases, for speed,      /* The code is duplicated for the caseless and caseful cases, for speed,
3685      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 3694  for (;;)
3694    
3695      if (op >= OP_NOTSTARI)     /* Caseless */      if (op >= OP_NOTSTARI)     /* Caseless */
3696        {        {
 #ifdef COMPILE_PCRE8  
       /* fc must be < 128 if UTF is enabled. */  
       foc = md->fcc[fc];  
 #else  
3697  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3698  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3699        if (utf && fc > 127)        if (utf && fc > 127)
# Line 3688  for (;;) Line 3705  for (;;)
3705        else        else
3706  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
3707          foc = TABLE_GET(fc, md->fcc, fc);          foc = TABLE_GET(fc, md->fcc, fc);
 #endif /* COMPILE_PCRE8 */  
3708    
3709  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3710        if (utf)        if (utf)
# Line 3702  for (;;) Line 3718  for (;;)
3718              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3719              }              }
3720            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3721            if (fc == d || (unsigned int) foc == d) RRETURN(MATCH_NOMATCH);            if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3722            }            }
3723          }          }
3724        else        else
# Line 4233  for (;;) Line 4249  for (;;)
4249              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4250              }              }
4251            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4252              if (md->partial != 0 &&
4253                  eptr + 1 >= md->end_subject &&
4254                  NLBLOCK->nltype == NLTYPE_FIXED &&
4255                  NLBLOCK->nllen == 2 &&
4256                  *eptr == NLBLOCK->nl[0])
4257                {
4258                md->hitend = TRUE;
4259                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4260                }
4261            eptr++;            eptr++;
4262            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4263            }            }
# Line 4517  for (;;) Line 4542  for (;;)
4542              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4543              }              }
4544            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4545              if (md->partial != 0 &&
4546                  eptr + 1 >= md->end_subject &&
4547                  NLBLOCK->nltype == NLTYPE_FIXED &&
4548                  NLBLOCK->nllen == 2 &&
4549                  *eptr == NLBLOCK->nl[0])
4550                {
4551                md->hitend = TRUE;
4552                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4553                }
4554            eptr++;            eptr++;
4555            }            }
4556          break;          break;
# Line 5021  for (;;) Line 5055  for (;;)
5055            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
5056            switch(ctype)            switch(ctype)
5057              {              {
5058              case OP_ANY:        /* This is the non-NL case */              case OP_ANY:               /* This is the non-NL case */
5059                if (md->partial != 0 &&    /* Take care with CRLF partial */
5060                    eptr >= md->end_subject &&
5061                    NLBLOCK->nltype == NLTYPE_FIXED &&
5062                    NLBLOCK->nllen == 2 &&
5063                    c == NLBLOCK->nl[0])
5064                  {
5065                  md->hitend = TRUE;
5066                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5067                  }
5068                break;
5069    
5070              case OP_ALLANY:              case OP_ALLANY:
5071              case OP_ANYBYTE:              case OP_ANYBYTE:
5072              break;              break;
# Line 5184  for (;;) Line 5229  for (;;)
5229            c = *eptr++;            c = *eptr++;
5230            switch(ctype)            switch(ctype)
5231              {              {
5232              case OP_ANY:     /* This is the non-NL case */              case OP_ANY:               /* This is the non-NL case */
5233                if (md->partial != 0 &&    /* Take care with CRLF partial */
5234                    eptr >= md->end_subject &&
5235                    NLBLOCK->nltype == NLTYPE_FIXED &&
5236                    NLBLOCK->nllen == 2 &&
5237                    c == NLBLOCK->nl[0])
5238                  {
5239                  md->hitend = TRUE;
5240                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5241                  }
5242                break;
5243    
5244              case OP_ALLANY:              case OP_ALLANY:
5245              case OP_ANYBYTE:              case OP_ANYBYTE:
5246              break;              break;
# Line 5585  for (;;) Line 5641  for (;;)
5641                  break;                  break;
5642                  }                  }
5643                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
5644                  if (md->partial != 0 &&    /* Take care with CRLF partial */
5645                      eptr + 1 >= md->end_subject &&
5646                      NLBLOCK->nltype == NLTYPE_FIXED &&
5647                      NLBLOCK->nllen == 2 &&
5648                      *eptr == NLBLOCK->nl[0])
5649                    {
5650                    md->hitend = TRUE;
5651                    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5652                    }
5653                eptr++;                eptr++;
5654                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5655                }                }
# Line 5602  for (;;) Line 5667  for (;;)
5667                  break;                  break;
5668                  }                  }
5669                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
5670                  if (md->partial != 0 &&    /* Take care with CRLF partial */
5671                      eptr + 1 >= md->end_subject &&
5672                      NLBLOCK->nltype == NLTYPE_FIXED &&
5673                      NLBLOCK->nllen == 2 &&
5674                      *eptr == NLBLOCK->nl[0])
5675                    {
5676                    md->hitend = TRUE;
5677                    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5678                    }
5679                eptr++;                eptr++;
5680                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5681                }                }
# Line 5866  for (;;) Line 5940  for (;;)
5940                break;                break;
5941                }                }
5942              if (IS_NEWLINE(eptr)) break;              if (IS_NEWLINE(eptr)) break;
5943                if (md->partial != 0 &&    /* Take care with CRLF partial */
5944                    eptr + 1 >= md->end_subject &&
5945                    NLBLOCK->nltype == NLTYPE_FIXED &&
5946                    NLBLOCK->nllen == 2 &&
5947                    *eptr == NLBLOCK->nl[0])
5948                  {
5949                  md->hitend = TRUE;
5950                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5951                  }
5952              eptr++;              eptr++;
5953              }              }
5954            break;            break;
# Line 6347  if (extra_data != NULL Line 6430  if (extra_data != NULL
6430    rc = PRIV(jit_exec)(re, extra_data->executable_jit,    rc = PRIV(jit_exec)(re, extra_data->executable_jit,
6431      (const pcre_uchar *)subject, length, start_offset, options,      (const pcre_uchar *)subject, length, start_offset, options,
6432      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)
6433      ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);      ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount,
6434        ((extra_data->flags & PCRE_EXTRA_MARK) != 0) ? extra_data->mark : NULL);
6435    
6436    /* PCRE_ERROR_NULL means that the selected normal or partial matching    /* PCRE_ERROR_NULL means that the selected normal or partial matching
6437    mode is not compiled. In this case we simply fallback to interpreter. */    mode is not compiled. In this case we simply fallback to interpreter. */
6438    
6439    if (rc != PCRE_ERROR_NULL) return rc;    if (rc != PCRE_ERROR_NULL) return rc;
6440    }    }
6441  #endif  #endif

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

  ViewVC Help
Powered by ViewVC 1.1.5