/[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 335 by ph10, Sat Apr 12 14:36:14 2008 UTC
# Line 6  Line 6 
6  and semantics are as close as possible to those of the Perl 5 language.  and semantics are as close as possible to those of the Perl 5 language.
7    
8                         Written by Philip Hazel                         Written by Philip Hazel
9             Copyright (c) 1997-2007 University of Cambridge             Copyright (c) 1997-2008 University of Cambridge
10    
11  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
12  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
# 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 1149  for (;;) Line 1148  for (;;)
1148      do ecode += GET(ecode,1); while (*ecode == OP_ALT);      do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1149      break;      break;
1150    
1151      /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating      /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
1152      that it may occur zero times. It may repeat infinitely, or not at all -      indicating that it may occur zero times. It may repeat infinitely, or not
1153      i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper      at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
1154      repeat limits are compiled as a number of copies, with the optional ones      with fixed upper repeat limits are compiled as a number of copies, with the
1155      preceded by BRAZERO or BRAMINZERO. */      optional ones preceded by BRAZERO or BRAMINZERO. */
1156    
1157      case OP_BRAZERO:      case OP_BRAZERO:
1158        {        {
# Line 1175  for (;;) Line 1174  for (;;)
1174        }        }
1175      break;      break;
1176    
1177        case OP_SKIPZERO:
1178          {
1179          next = ecode+1;
1180          do next += GET(next,1); while (*next == OP_ALT);
1181          ecode = next + 1 + LINK_SIZE;
1182          }
1183        break;
1184    
1185      /* End of a group, repeated or non-repeating. */      /* End of a group, repeated or non-repeating. */
1186    
1187      case OP_KET:      case OP_KET:
# Line 1527  for (;;) Line 1534  for (;;)
1534        case 0x000d:        case 0x000d:
1535        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1536        break;        break;
1537    
1538        case 0x000a:        case 0x000a:
1539          break;
1540    
1541        case 0x000b:        case 0x000b:
1542        case 0x000c:        case 0x000c:
1543        case 0x0085:        case 0x0085:
1544        case 0x2028:        case 0x2028:
1545        case 0x2029:        case 0x2029:
1546          if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
1547        break;        break;
1548        }        }
1549      ecode++;      ecode++;
# Line 2089  for (;;) Line 2100  for (;;)
2100            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
2101            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2102            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2103            BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
2104            }            }
2105          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2106          }          }
# Line 2955  for (;;) Line 2966  for (;;)
2966              case 0x000d:              case 0x000d:
2967              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
2968              break;              break;
2969    
2970              case 0x000a:              case 0x000a:
2971                break;
2972    
2973              case 0x000b:              case 0x000b:
2974              case 0x000c:              case 0x000c:
2975              case 0x0085:              case 0x0085:
2976              case 0x2028:              case 0x2028:
2977              case 0x2029:              case 0x2029:
2978                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2979              break;              break;
2980              }              }
2981            }            }
# Line 3094  for (;;) Line 3109  for (;;)
3109          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3110            {            {
3111            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3112               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
3113              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3114            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3115            }            }
3116          break;          break;
3117    
# Line 3114  for (;;) Line 3129  for (;;)
3129          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3130            {            {
3131            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3132               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))
3133              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3134            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3135            }            }
3136          break;          break;
3137    
# Line 3173  for (;;) Line 3188  for (;;)
3188              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3189              break;              break;
3190              case 0x000a:              case 0x000a:
3191                break;
3192    
3193              case 0x000b:              case 0x000b:
3194              case 0x000c:              case 0x000c:
3195              case 0x0085:              case 0x0085:
3196                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3197              break;              break;
3198              }              }
3199            }            }
# Line 3427  for (;;) Line 3445  for (;;)
3445                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3446                break;                break;
3447                case 0x000a:                case 0x000a:
3448                  break;
3449    
3450                case 0x000b:                case 0x000b:
3451                case 0x000c:                case 0x000c:
3452                case 0x0085:                case 0x0085:
3453                case 0x2028:                case 0x2028:
3454                case 0x2029:                case 0x2029:
3455                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3456                break;                break;
3457                }                }
3458              break;              break;
# Line 3583  for (;;) Line 3604  for (;;)
3604                case 0x000d:                case 0x000d:
3605                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3606                break;                break;
3607    
3608                case 0x000a:                case 0x000a:
3609                  break;
3610    
3611                case 0x000b:                case 0x000b:
3612                case 0x000c:                case 0x000c:
3613                case 0x0085:                case 0x0085:
3614                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3615                break;                break;
3616                }                }
3617              break;              break;
# Line 3884  for (;;) Line 3909  for (;;)
3909                }                }
3910              else              else
3911                {                {
3912                if (c != 0x000a && c != 0x000b && c != 0x000c &&                if (c != 0x000a &&
3913                    c != 0x0085 && c != 0x2028 && c != 0x2029)                    (md->bsr_anycrlf ||
3914                       (c != 0x000b && c != 0x000c &&
3915                        c != 0x0085 && c != 0x2028 && c != 0x2029)))
3916                  break;                  break;
3917                eptr += len;                eptr += len;
3918                }                }
# Line 4075  for (;;) Line 4102  for (;;)
4102                }                }
4103              else              else
4104                {                {
4105                if (c != 0x000a && c != 0x000b && c != 0x000c && c != 0x0085)                if (c != 0x000a &&
4106                      (md->bsr_anycrlf ||
4107                        (c != 0x000b && c != 0x000c && c != 0x0085)))
4108                  break;                  break;
4109                eptr++;                eptr++;
4110                }                }
# Line 4225  HEAP_RETURN: Line 4254  HEAP_RETURN:
4254  switch (frame->Xwhere)  switch (frame->Xwhere)
4255    {    {
4256    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)
4257    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)
4258    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)
4259    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)
4260    LBL(33) LBL(34) LBL(35) LBL(36) LBL(37) LBL(38) LBL(39) LBL(40)    LBL(53) LBL(54)
4261    LBL(41) LBL(42) LBL(43) LBL(44) LBL(45) LBL(46) LBL(47)  #ifdef SUPPORT_UTF8
4262      LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
4263      LBL(32) LBL(34) LBL(42) LBL(46)
4264    #ifdef SUPPORT_UCP
4265      LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
4266    #endif  /* SUPPORT_UCP */
4267    #endif  /* SUPPORT_UTF8 */
4268    default:    default:
4269    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));
4270    return PCRE_ERROR_INTERNAL;    return PCRE_ERROR_INTERNAL;
# Line 4408  if (re->magic_number != MAGIC_NUMBER) Line 4443  if (re->magic_number != MAGIC_NUMBER)
4443  /* Set up other data */  /* Set up other data */
4444    
4445  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
4446  startline = (re->options & PCRE_STARTLINE) != 0;  startline = (re->flags & PCRE_STARTLINE) != 0;
4447  firstline = (re->options & PCRE_FIRSTLINE) != 0;  firstline = (re->options & PCRE_FIRSTLINE) != 0;
4448    
4449  /* 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 4470  md->recursive = NULL;
4470  md->lcc = tables + lcc_offset;  md->lcc = tables + lcc_offset;
4471  md->ctypes = tables + ctypes_offset;  md->ctypes = tables + ctypes_offset;
4472    
4473    /* Handle different \R options. */
4474    
4475    switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
4476      {
4477      case 0:
4478      if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
4479        md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
4480      else
4481    #ifdef BSR_ANYCRLF
4482      md->bsr_anycrlf = TRUE;
4483    #else
4484      md->bsr_anycrlf = FALSE;
4485    #endif
4486      break;
4487    
4488      case PCRE_BSR_ANYCRLF:
4489      md->bsr_anycrlf = TRUE;
4490      break;
4491    
4492      case PCRE_BSR_UNICODE:
4493      md->bsr_anycrlf = FALSE;
4494      break;
4495    
4496      default: return PCRE_ERROR_BADNEWLINE;
4497      }
4498    
4499  /* Handle different types of newline. The three bits give eight cases. If  /* Handle different types of newline. The three bits give eight cases. If
4500  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. */
4501    
4502  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
4503         PCRE_NEWLINE_BITS)          (pcre_uint32)options) & PCRE_NEWLINE_BITS)
4504    {    {
4505    case 0: newline = NEWLINE; break;   /* Compile-time default */    case 0: newline = NEWLINE; break;   /* Compile-time default */
4506    case PCRE_NEWLINE_CR: newline = '\r'; break;    case PCRE_NEWLINE_CR: newline = '\r'; break;
# Line 4478  else Line 4539  else
4539  /* 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
4540  moment. */  moment. */
4541    
4542  if (md->partial && (re->options & PCRE_NOPARTIAL) != 0)  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
4543    return PCRE_ERROR_BADPARTIAL;    return PCRE_ERROR_BADPARTIAL;
4544    
4545  /* 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 4616  studied, there may be a bitmap of possib
4616    
4617  if (!anchored)  if (!anchored)
4618    {    {
4619    if ((re->options & PCRE_FIRSTSET) != 0)    if ((re->flags & PCRE_FIRSTSET) != 0)
4620      {      {
4621      first_byte = re->first_byte & 255;      first_byte = re->first_byte & 255;
4622      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 4631  if (!anchored)
4631  /* For anchored or unanchored matches, there may be a "last known required  /* For anchored or unanchored matches, there may be a "last known required
4632  character" set. */  character" set. */
4633    
4634  if ((re->options & PCRE_REQCHSET) != 0)  if ((re->flags & PCRE_REQCHSET) != 0)
4635    {    {
4636    req_byte = re->req_byte & 255;    req_byte = re->req_byte & 255;
4637    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 4647  the loop runs just once. */
4647  for(;;)  for(;;)
4648    {    {
4649    USPTR save_end_subject = end_subject;    USPTR save_end_subject = end_subject;
4650    USPTR new_start_match;    USPTR new_start_match;
4651    
4652    /* Reset the maximum number of extractions we might see. */    /* Reset the maximum number of extractions we might see. */
4653    
# Line 4617  for(;;) Line 4678  for(;;)
4678      if (first_byte_caseless)      if (first_byte_caseless)
4679        while (start_match < end_subject &&        while (start_match < end_subject &&
4680               md->lcc[*start_match] != first_byte)               md->lcc[*start_match] != first_byte)
4681          start_match++;          { NEXTCHAR(start_match); }
4682      else      else
4683        while (start_match < end_subject && *start_match != first_byte)        while (start_match < end_subject && *start_match != first_byte)
4684          start_match++;          { NEXTCHAR(start_match); }
4685      }      }
4686    
4687    /* 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 4691  for(;;)
4691      if (start_match > md->start_subject + start_offset)      if (start_match > md->start_subject + start_offset)
4692        {        {
4693        while (start_match <= end_subject && !WAS_NEWLINE(start_match))        while (start_match <= end_subject && !WAS_NEWLINE(start_match))
4694          start_match++;          { NEXTCHAR(start_match); }
4695    
4696        /* 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,
4697        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 4712  for(;;)
4712      while (start_match < end_subject)      while (start_match < end_subject)
4713        {        {
4714        register unsigned int c = *start_match;        register unsigned int c = *start_match;
4715        if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break;        if ((start_bits[c/8] & (1 << (c&7))) == 0)
4716            { NEXTCHAR(start_match); }
4717          else break;
4718        }        }
4719      }      }
4720    
# Line 4730  for(;;) Line 4793  for(;;)
4793    md->start_match_ptr = start_match;    md->start_match_ptr = start_match;
4794    md->match_call_count = 0;    md->match_call_count = 0;
4795    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);
4796    
4797    switch(rc)    switch(rc)
4798      {      {
4799      /* NOMATCH and PRUNE advance by one character. THEN at this level acts      /* NOMATCH and PRUNE advance by one character. THEN at this level acts
4800      exactly like PRUNE. */      exactly like PRUNE. */
4801    
4802      case MATCH_NOMATCH:      case MATCH_NOMATCH:
4803      case MATCH_PRUNE:      case MATCH_PRUNE:
4804      case MATCH_THEN:      case MATCH_THEN:
4805      new_start_match = start_match + 1;      new_start_match = start_match + 1;
4806  #ifdef SUPPORT_UTF8  #ifdef SUPPORT_UTF8
4807      if (utf8)      if (utf8)
4808        while(new_start_match < end_subject && (*new_start_match & 0xc0) == 0x80)        while(new_start_match < end_subject && (*new_start_match & 0xc0) == 0x80)
4809          new_start_match++;          new_start_match++;
4810  #endif  #endif
4811      break;      break;
4812    
4813      /* SKIP passes back the next starting point explicitly. */      /* SKIP passes back the next starting point explicitly. */
4814    
4815      case MATCH_SKIP:      case MATCH_SKIP:
4816      new_start_match = md->start_match_ptr;      new_start_match = md->start_match_ptr;
4817      break;      break;
4818    
4819      /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */      /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
4820    
4821      case MATCH_COMMIT:      case MATCH_COMMIT:
4822      rc = MATCH_NOMATCH;      rc = MATCH_NOMATCH;
4823      goto ENDLOOP;      goto ENDLOOP;
4824    
4825      /* Any other return is some kind of error. */      /* Any other return is some kind of error. */
4826    
4827      default:      default:
4828      goto ENDLOOP;      goto ENDLOOP;
4829      }      }
4830    
4831    /* 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"
4832    result. Reset the code to MATCH_NOMATCH for subsequent checking. */    result. Reset the code to MATCH_NOMATCH for subsequent checking. */
4833    
4834    rc = MATCH_NOMATCH;    rc = MATCH_NOMATCH;
4835    
4836    /* 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
4837    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 4848  for(;;)
4848    
4849    if (anchored || start_match > end_subject) break;    if (anchored || start_match > end_subject) break;
4850    
4851    /* 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
4852    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
4853    character. */    or ANY or ANYCRLF, advance the match position by one more character. */
4854    
4855    if (start_match[-1] == '\r' &&    if (start_match[-1] == '\r' &&
4856         (md->nltype == NLTYPE_ANY ||        start_match < end_subject &&
4857          md->nltype == NLTYPE_ANYCRLF ||        *start_match == '\n' &&
4858          md->nllen == 2) &&        (re->flags & PCRE_HASCRORLF) == 0 &&
4859         start_match < end_subject &&          (md->nltype == NLTYPE_ANY ||
4860         *start_match == '\n')           md->nltype == NLTYPE_ANYCRLF ||
4861             md->nllen == 2))
4862      start_match++;      start_match++;
4863    
4864    }   /* End of for(;;) "bumpalong" loop */    }   /* End of for(;;) "bumpalong" loop */

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

  ViewVC Help
Powered by ViewVC 1.1.5