/[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 210 by ph10, Wed Aug 8 14:24:50 2007 UTC revision 294 by ph10, Sat Dec 29 16:55:59 2007 UTC
# Line 43  pattern matching using an NFA algorithm, Line 43  pattern matching using an NFA algorithm,
43  possible. There are also some static supporting functions. */  possible. There are also some static supporting functions. */
44    
45  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
46  #include <config.h>  #include "config.h"
47  #endif  #endif
48    
49  #define NLBLOCK md             /* Block containing newline information */  #define NLBLOCK md             /* Block containing newline information */
# Line 68  defined PCRE_ERROR_xxx codes, which are Line 68  defined PCRE_ERROR_xxx codes, which are
68  #define MATCH_MATCH        1  #define MATCH_MATCH        1
69  #define MATCH_NOMATCH      0  #define MATCH_NOMATCH      0
70    
71  /* Special internal returns from the match() function. Make them sufficiently  /* Special internal returns from the match() function. Make them sufficiently
72  negative to avoid the external error codes. */  negative to avoid the external error codes. */
73    
74  #define MATCH_COMMIT       (-999)  #define MATCH_COMMIT       (-999)
# Line 211  variable instead of being passed in the Line 211  variable instead of being passed in the
211  ****************************************************************************  ****************************************************************************
212  ***************************************************************************/  ***************************************************************************/
213    
214    /* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
215  /* Numbers for RMATCH calls */  below must be updated in sync.  */
216    
217  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,
218         RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,         RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
219         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
220         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
221         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
222         RM51,  RM52, RM53 };         RM51,  RM52, RM53, RM54 };
   
223    
224  /* These versions of the macros use the stack, as normal. There are debugging  /* These versions of the macros use the stack, as normal. There are debugging
225  versions and production versions. Note that the "rw" argument of RMATCH isn't  versions and production versions. Note that the "rw" argument of RMATCH isn't
# Line 622  for (;;) Line 621  for (;;)
621    switch(op)    switch(op)
622      {      {
623      case OP_FAIL:      case OP_FAIL:
624      return MATCH_NOMATCH;      RRETURN(MATCH_NOMATCH);
625    
626      case OP_PRUNE:      case OP_PRUNE:
627      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
628        ims, eptrb, flags, RM51);        ims, eptrb, flags, RM51);
629      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
630      return MATCH_PRUNE;      RRETURN(MATCH_PRUNE);
631    
632      case OP_COMMIT:      case OP_COMMIT:
633      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
634        ims, eptrb, flags, RM52);        ims, eptrb, flags, RM52);
635      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
636      return MATCH_COMMIT;      RRETURN(MATCH_COMMIT);
637    
638      case OP_SKIP:      case OP_SKIP:
639      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
640        ims, eptrb, flags, RM53);        ims, eptrb, flags, RM53);
641      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
642      md->start_match_ptr = eptr;   /* Pass back current position */      md->start_match_ptr = eptr;   /* Pass back current position */
643      return MATCH_SKIP;      RRETURN(MATCH_SKIP);
644    
645      case OP_THEN:      case OP_THEN:
646      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,      RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
647        ims, eptrb, flags, RM53);        ims, eptrb, flags, RM54);
648      if (rrc != MATCH_NOMATCH) RRETURN(rrc);      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
649      return MATCH_THEN;      RRETURN(MATCH_THEN);
650    
651      /* Handle a capturing bracket. If there is space in the offset vector, save      /* Handle a capturing bracket. If there is space in the offset vector, save
652      the current subject position in the working slot at the top of the vector.      the current subject position in the working slot at the top of the vector.
653      We mustn't change the current values of the data slot, because they may be      We mustn't change the current values of the data slot, because they may be
# Line 1527  for (;;) Line 1526  for (;;)
1526        case 0x000d:        case 0x000d:
1527        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1528        break;        break;
1529    
1530        case 0x000a:        case 0x000a:
1531          break;
1532    
1533        case 0x000b:        case 0x000b:
1534        case 0x000c:        case 0x000c:
1535        case 0x0085:        case 0x0085:
1536        case 0x2028:        case 0x2028:
1537        case 0x2029:        case 0x2029:
1538          if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
1539        break;        break;
1540        }        }
1541      ecode++;      ecode++;
# Line 2089  for (;;) Line 2092  for (;;)
2092            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
2093            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2094            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2095            BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2096            }            }
2097          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2098          }          }
# Line 2955  for (;;) Line 2958  for (;;)
2958              case 0x000d:              case 0x000d:
2959              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
2960              break;              break;
2961    
2962              case 0x000a:              case 0x000a:
2963                break;
2964    
2965              case 0x000b:              case 0x000b:
2966              case 0x000c:              case 0x000c:
2967              case 0x0085:              case 0x0085:
2968              case 0x2028:              case 0x2028:
2969              case 0x2029:              case 0x2029:
2970                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2971              break;              break;
2972              }              }
2973            }            }
# Line 3094  for (;;) Line 3101  for (;;)
3101          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3102            {            {
3103            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3104               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
3105              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3106            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3107            }            }
3108          break;          break;
3109    
# Line 3114  for (;;) Line 3121  for (;;)
3121          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3122            {            {
3123            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3124               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))
3125              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3126            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3127            }            }
3128          break;          break;
3129    
# Line 3173  for (;;) Line 3180  for (;;)
3180              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3181              break;              break;
3182              case 0x000a:              case 0x000a:
3183                break;
3184    
3185              case 0x000b:              case 0x000b:
3186              case 0x000c:              case 0x000c:
3187              case 0x0085:              case 0x0085:
3188                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3189              break;              break;
3190              }              }
3191            }            }
# Line 3427  for (;;) Line 3437  for (;;)
3437                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3438                break;                break;
3439                case 0x000a:                case 0x000a:
3440                  break;
3441    
3442                case 0x000b:                case 0x000b:
3443                case 0x000c:                case 0x000c:
3444                case 0x0085:                case 0x0085:
3445                case 0x2028:                case 0x2028:
3446                case 0x2029:                case 0x2029:
3447                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3448                break;                break;
3449                }                }
3450              break;              break;
# Line 3583  for (;;) Line 3596  for (;;)
3596                case 0x000d:                case 0x000d:
3597                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3598                break;                break;
3599    
3600                case 0x000a:                case 0x000a:
3601                  break;
3602    
3603                case 0x000b:                case 0x000b:
3604                case 0x000c:                case 0x000c:
3605                case 0x0085:                case 0x0085:
3606                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3607                break;                break;
3608                }                }
3609              break;              break;
# Line 3884  for (;;) Line 3901  for (;;)
3901                }                }
3902              else              else
3903                {                {
3904                if (c != 0x000a && c != 0x000b && c != 0x000c &&                if (c != 0x000a &&
3905                    c != 0x0085 && c != 0x2028 && c != 0x2029)                    (md->bsr_anycrlf ||
3906                       (c != 0x000b && c != 0x000c &&
3907                        c != 0x0085 && c != 0x2028 && c != 0x2029)))
3908                  break;                  break;
3909                eptr += len;                eptr += len;
3910                }                }
# Line 4075  for (;;) Line 4094  for (;;)
4094                }                }
4095              else              else
4096                {                {
4097                if (c != 0x000a && c != 0x000b && c != 0x000c && c != 0x0085)                if (c != 0x000a &&
4098                      (md->bsr_anycrlf ||
4099                        (c != 0x000b && c != 0x000c && c != 0x0085)))
4100                  break;                  break;
4101                eptr++;                eptr++;
4102                }                }
# Line 4225  HEAP_RETURN: Line 4246  HEAP_RETURN:
4246  switch (frame->Xwhere)  switch (frame->Xwhere)
4247    {    {
4248    LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)    LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
4249    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(16)    LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
4250    LBL(17) LBL(18) LBL(19) LBL(20) LBL(21) LBL(22) LBL(23) LBL(24)    LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
4251    LBL(25) LBL(26) LBL(27) LBL(28) LBL(29) LBL(30) LBL(31) LBL(32)    LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
4252    LBL(33) LBL(34) LBL(35) LBL(36) LBL(37) LBL(38) LBL(39) LBL(40)    LBL(53) LBL(54)
4253    LBL(41) LBL(42) LBL(43) LBL(44) LBL(45) LBL(46) LBL(47)  #ifdef SUPPORT_UTF8
4254      LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
4255      LBL(32) LBL(34) LBL(42) LBL(46)
4256    #ifdef SUPPORT_UCP
4257      LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
4258    #endif  /* SUPPORT_UCP */
4259    #endif  /* SUPPORT_UTF8 */
4260    default:    default:
4261    DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));    DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
4262    return PCRE_ERROR_INTERNAL;    return PCRE_ERROR_INTERNAL;
# Line 4408  if (re->magic_number != MAGIC_NUMBER) Line 4435  if (re->magic_number != MAGIC_NUMBER)
4435  /* Set up other data */  /* Set up other data */
4436    
4437  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
4438  startline = (re->options & PCRE_STARTLINE) != 0;  startline = (re->flags & PCRE_STARTLINE) != 0;
4439  firstline = (re->options & PCRE_FIRSTLINE) != 0;  firstline = (re->options & PCRE_FIRSTLINE) != 0;
4440    
4441  /* The code starts after the real_pcre block and the capture name table. */  /* The code starts after the real_pcre block and the capture name table. */
# Line 4435  md->recursive = NULL; Line 4462  md->recursive = NULL;
4462  md->lcc = tables + lcc_offset;  md->lcc = tables + lcc_offset;
4463  md->ctypes = tables + ctypes_offset;  md->ctypes = tables + ctypes_offset;
4464    
4465    /* Handle different \R options. */
4466    
4467    switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
4468      {
4469      case 0:
4470      if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
4471        md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
4472      else
4473    #ifdef BSR_ANYCRLF
4474      md->bsr_anycrlf = TRUE;
4475    #else
4476      md->bsr_anycrlf = FALSE;
4477    #endif
4478      break;
4479    
4480      case PCRE_BSR_ANYCRLF:
4481      md->bsr_anycrlf = TRUE;
4482      break;
4483    
4484      case PCRE_BSR_UNICODE:
4485      md->bsr_anycrlf = FALSE;
4486      break;
4487    
4488      default: return PCRE_ERROR_BADNEWLINE;
4489      }
4490    
4491  /* Handle different types of newline. The three bits give eight cases. If  /* Handle different types of newline. The three bits give eight cases. If
4492  nothing is set at run time, whatever was used at compile time applies. */  nothing is set at run time, whatever was used at compile time applies. */
4493    
4494  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
4495         PCRE_NEWLINE_BITS)          (pcre_uint32)options) & PCRE_NEWLINE_BITS)
4496    {    {
4497    case 0: newline = NEWLINE; break;   /* Compile-time default */    case 0: newline = NEWLINE; break;   /* Compile-time default */
4498    case PCRE_NEWLINE_CR: newline = '\r'; break;    case PCRE_NEWLINE_CR: newline = '\r'; break;
# Line 4478  else Line 4531  else
4531  /* Partial matching is supported only for a restricted set of regexes at the  /* Partial matching is supported only for a restricted set of regexes at the
4532  moment. */  moment. */
4533    
4534  if (md->partial && (re->options & PCRE_NOPARTIAL) != 0)  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
4535    return PCRE_ERROR_BADPARTIAL;    return PCRE_ERROR_BADPARTIAL;
4536    
4537  /* Check a UTF-8 string if required. Unfortunately there's no way of passing  /* Check a UTF-8 string if required. Unfortunately there's no way of passing
# Line 4555  studied, there may be a bitmap of possib Line 4608  studied, there may be a bitmap of possib
4608    
4609  if (!anchored)  if (!anchored)
4610    {    {
4611    if ((re->options & PCRE_FIRSTSET) != 0)    if ((re->flags & PCRE_FIRSTSET) != 0)
4612      {      {
4613      first_byte = re->first_byte & 255;      first_byte = re->first_byte & 255;
4614      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
# Line 4570  if (!anchored) Line 4623  if (!anchored)
4623  /* For anchored or unanchored matches, there may be a "last known required  /* For anchored or unanchored matches, there may be a "last known required
4624  character" set. */  character" set. */
4625    
4626  if ((re->options & PCRE_REQCHSET) != 0)  if ((re->flags & PCRE_REQCHSET) != 0)
4627    {    {
4628    req_byte = re->req_byte & 255;    req_byte = re->req_byte & 255;
4629    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
# Line 4586  the loop runs just once. */ Line 4639  the loop runs just once. */
4639  for(;;)  for(;;)
4640    {    {
4641    USPTR save_end_subject = end_subject;    USPTR save_end_subject = end_subject;
4642    USPTR new_start_match;    USPTR new_start_match;
4643    
4644    /* Reset the maximum number of extractions we might see. */    /* Reset the maximum number of extractions we might see. */
4645    
# Line 4617  for(;;) Line 4670  for(;;)
4670      if (first_byte_caseless)      if (first_byte_caseless)
4671        while (start_match < end_subject &&        while (start_match < end_subject &&
4672               md->lcc[*start_match] != first_byte)               md->lcc[*start_match] != first_byte)
4673          start_match++;          { NEXTCHAR(start_match); }
4674      else      else
4675        while (start_match < end_subject && *start_match != first_byte)        while (start_match < end_subject && *start_match != first_byte)
4676          start_match++;          { NEXTCHAR(start_match); }
4677      }      }
4678    
4679    /* Or to just after a linebreak for a multiline match if possible */    /* Or to just after a linebreak for a multiline match if possible */
# Line 4630  for(;;) Line 4683  for(;;)
4683      if (start_match > md->start_subject + start_offset)      if (start_match > md->start_subject + start_offset)
4684        {        {
4685        while (start_match <= end_subject && !WAS_NEWLINE(start_match))        while (start_match <= end_subject && !WAS_NEWLINE(start_match))
4686          start_match++;          { NEXTCHAR(start_match); }
4687    
4688        /* If we have just passed a CR and the newline option is ANY or ANYCRLF,        /* If we have just passed a CR and the newline option is ANY or ANYCRLF,
4689        and we are now at a LF, advance the match position by one more character.        and we are now at a LF, advance the match position by one more character.
# Line 4651  for(;;) Line 4704  for(;;)
4704      while (start_match < end_subject)      while (start_match < end_subject)
4705        {        {
4706        register unsigned int c = *start_match;        register unsigned int c = *start_match;
4707        if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break;        if ((start_bits[c/8] & (1 << (c&7))) == 0)
4708            { NEXTCHAR(start_match); }
4709          else break;
4710        }        }
4711      }      }
4712    
# Line 4730  for(;;) Line 4785  for(;;)
4785    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
4786    md->match_call_count = 0;    md->match_call_count = 0;
4787    rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);    rc = match(start_match, md->start_code, start_match, 2, md, ims, NULL, 0, 0);
4788    
4789    switch(rc)    switch(rc)
4790      {      {
4791      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. THEN at this level acts
4792      exactly like PRUNE. */      exactly like PRUNE. */
4793    
4794      case MATCH_NOMATCH:      case MATCH_NOMATCH:
4795      case MATCH_PRUNE:      case MATCH_PRUNE:
4796      case MATCH_THEN:      case MATCH_THEN:
4797      new_start_match = start_match + 1;      new_start_match = start_match + 1;
4798  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
4799      if (utf8)      if (utf8)
4800        while(new_start_match < end_subject && (*new_start_match & 0xc0) == 0x80)        while(new_start_match < end_subject && (*new_start_match & 0xc0) == 0x80)
4801          new_start_match++;          new_start_match++;
4802  #endif  #endif
4803      break;      break;
4804    
4805      /* SKIP passes back the next starting point explicitly. */      /* SKIP passes back the next starting point explicitly. */
4806    
4807      case MATCH_SKIP:      case MATCH_SKIP:
4808      new_start_match = md->start_match_ptr;      new_start_match = md->start_match_ptr;
4809      break;      break;
4810    
4811      /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */      /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
4812    
4813      case MATCH_COMMIT:      case MATCH_COMMIT:
4814      rc = MATCH_NOMATCH;      rc = MATCH_NOMATCH;
4815      goto ENDLOOP;      goto ENDLOOP;
4816    
4817      /* Any other return is some kind of error. */      /* Any other return is some kind of error. */
4818    
4819      default:      default:
4820      goto ENDLOOP;      goto ENDLOOP;
4821      }      }
4822    
4823    /* Control reaches here for the various types of "no match at this point"    /* Control reaches here for the various types of "no match at this point"
4824    result. Reset the code to MATCH_NOMATCH for subsequent checking. */    result. Reset the code to MATCH_NOMATCH for subsequent checking. */
4825    
4826    rc = MATCH_NOMATCH;    rc = MATCH_NOMATCH;
4827    
4828    /* If PCRE_FIRSTLINE is set, the match must happen before or at the first    /* If PCRE_FIRSTLINE is set, the match must happen before or at the first
4829    newline in the subject (though it may continue over the newline). Therefore,    newline in the subject (though it may continue over the newline). Therefore,
# Line 4785  for(;;) Line 4840  for(;;)
4840    
4841    if (anchored || start_match > end_subject) break;    if (anchored || start_match > end_subject) break;
4842    
4843    /* If we have just passed a CR and the newline option is CRLF or ANY or    /* If we have just passed a CR and we are now at a LF, and the pattern does
4844    ANYCRLF, and we are now at a LF, advance the match position by one more    not contain any explicit matches for \r or \n, and the newline option is CRLF
4845    character. */    or ANY or ANYCRLF, advance the match position by one more character. */
4846    
4847    if (start_match[-1] == '\r' &&    if (start_match[-1] == '\r' &&
4848         (md->nltype == NLTYPE_ANY ||        start_match < end_subject &&
4849          md->nltype == NLTYPE_ANYCRLF ||        *start_match == '\n' &&
4850          md->nllen == 2) &&        (re->flags & PCRE_HASCRORLF) == 0 &&
4851         start_match < end_subject &&          (md->nltype == NLTYPE_ANY ||
4852         *start_match == '\n')           md->nltype == NLTYPE_ANYCRLF ||
4853             md->nllen == 2))
4854      start_match++;      start_match++;
4855    
4856    }   /* End of for(;;) "bumpalong" loop */    }   /* End of for(;;) "bumpalong" loop */

Legend:
Removed from v.210  
changed lines
  Added in v.294

  ViewVC Help
Powered by ViewVC 1.1.5