/[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 199 by ph10, Tue Jul 31 14:39:09 2007 UTC revision 365 by ph10, Fri Jul 11 17:06:55 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 42  POSSIBILITY OF SUCH DAMAGE. Line 42  POSSIBILITY OF SUCH DAMAGE.
42  pattern matching using an NFA algorithm, trying to mimic Perl as closely as  pattern matching using an NFA algorithm, trying to mimic Perl as closely as
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 */
50  #define PSSTART start_subject  /* Field containing processed string start */  #define PSSTART start_subject  /* Field containing processed string start */
# 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
72    negative to avoid the external error codes. */
73    
74    #define MATCH_COMMIT       (-999)
75    #define MATCH_PRUNE        (-998)
76    #define MATCH_SKIP         (-997)
77    #define MATCH_THEN         (-996)
78    
79  /* Maximum number of ints of offset to save on the stack for recursive calls.  /* Maximum number of ints of offset to save on the stack for recursive calls.
80  If the offset vector is bigger, malloc is used. This should be a multiple of 3,  If the offset vector is bigger, malloc is used. This should be a multiple of 3,
81  because the offset vector is always a multiple of 3 long. */  because the offset vector is always a multiple of 3 long. */
# Line 150  printf("\n"); Line 158  printf("\n");
158    
159  if (length > md->end_subject - eptr) return FALSE;  if (length > md->end_subject - eptr) return FALSE;
160    
161  /* Separate the caselesss case for speed */  /* Separate the caseless case for speed. In UTF-8 mode we can only do this
162    properly if Unicode properties are supported. Otherwise, we can check only
163    ASCII characters. */
164    
165  if ((ims & PCRE_CASELESS) != 0)  if ((ims & PCRE_CASELESS) != 0)
166    {    {
167    #ifdef SUPPORT_UTF8
168    #ifdef SUPPORT_UCP
169      if (md->utf8)
170        {
171        USPTR endptr = eptr + length;
172        while (eptr < endptr)
173          {
174          int c, d;
175          GETCHARINC(c, eptr);
176          GETCHARINC(d, p);
177          if (c != d && c != UCD_OTHERCASE(d)) return FALSE;
178          }
179        }
180      else
181    #endif
182    #endif
183    
184      /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
185      is no UCP support. */
186    
187    while (length-- > 0)    while (length-- > 0)
188      if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE;      { if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE; }
189    }    }
190    
191    /* In the caseful case, we can just compare the bytes, whether or not we
192    are in UTF-8 mode. */
193    
194  else  else
195    { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }    { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
196    
# Line 203  variable instead of being passed in the Line 237  variable instead of being passed in the
237  ****************************************************************************  ****************************************************************************
238  ***************************************************************************/  ***************************************************************************/
239    
240    /* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
241  /* Numbers for RMATCH calls */  below must be updated in sync.  */
242    
243  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,  enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,
244         RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,         RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
245         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,         RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
246         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,         RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
247         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50 };         RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
248           RM51,  RM52, RM53, RM54 };
249    
250  /* 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
251  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 612  for (;;) Line 646  for (;;)
646    
647    switch(op)    switch(op)
648      {      {
649        case OP_FAIL:
650        RRETURN(MATCH_NOMATCH);
651    
652        case OP_PRUNE:
653        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
654          ims, eptrb, flags, RM51);
655        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
656        RRETURN(MATCH_PRUNE);
657    
658        case OP_COMMIT:
659        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
660          ims, eptrb, flags, RM52);
661        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
662        RRETURN(MATCH_COMMIT);
663    
664        case OP_SKIP:
665        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
666          ims, eptrb, flags, RM53);
667        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
668        md->start_match_ptr = eptr;   /* Pass back current position */
669        RRETURN(MATCH_SKIP);
670    
671        case OP_THEN:
672        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
673          ims, eptrb, flags, RM54);
674        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
675        RRETURN(MATCH_THEN);
676    
677      /* 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
678      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.
679      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 653  for (;;) Line 715  for (;;)
715          {          {
716          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,          RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md,
717            ims, eptrb, flags, RM1);            ims, eptrb, flags, RM1);
718          if (rrc != MATCH_NOMATCH) RRETURN(rrc);          if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
719          md->capture_last = save_capture_last;          md->capture_last = save_capture_last;
720          ecode += GET(ecode, 1);          ecode += GET(ecode, 1);
721          }          }
# Line 712  for (;;) Line 774  for (;;)
774    
775        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,        RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims,
776          eptrb, flags, RM2);          eptrb, flags, RM2);
777        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
778        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
779        }        }
780      /* Control never reaches here. */      /* Control never reaches here. */
# Line 760  for (;;) Line 822  for (;;)
822          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);          ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
823          while (*ecode == OP_ALT) ecode += GET(ecode, 1);          while (*ecode == OP_ALT) ecode += GET(ecode, 1);
824          }          }
825        else if (rrc != MATCH_NOMATCH)        else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
826          {          {
827          RRETURN(rrc);         /* Need braces because of following else */          RRETURN(rrc);         /* Need braces because of following else */
828          }          }
# Line 797  for (;;) Line 859  for (;;)
859      break;      break;
860    
861    
862      /* End of the pattern. If we are in a top-level recursion, we should      /* End of the pattern, either real or forced. If we are in a top-level
863      restore the offsets appropriately and continue from after the call. */      recursion, we should restore the offsets appropriately and continue from
864        after the call. */
865    
866        case OP_ACCEPT:
867      case OP_END:      case OP_END:
868      if (md->recursive != NULL && md->recursive->group_num == 0)      if (md->recursive != NULL && md->recursive->group_num == 0)
869        {        {
# Line 820  for (;;) Line 884  for (;;)
884      if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);      if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH);
885      md->end_match_ptr = eptr;           /* Record where we ended */      md->end_match_ptr = eptr;           /* Record where we ended */
886      md->end_offset_top = offset_top;    /* and how many extracts were taken */      md->end_offset_top = offset_top;    /* and how many extracts were taken */
887      md->start_match_ptr = mstart;  /* and the start (\K can modify) */      md->start_match_ptr = mstart;       /* and the start (\K can modify) */
888      RRETURN(MATCH_MATCH);      RRETURN(MATCH_MATCH);
889    
890      /* Change option settings */      /* Change option settings */
# Line 844  for (;;) Line 908  for (;;)
908        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
909          RM4);          RM4);
910        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH) break;
911        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
912        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
913        }        }
914      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 871  for (;;) Line 935  for (;;)
935        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0,
936          RM5);          RM5);
937        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
938        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
939        ecode += GET(ecode,1);        ecode += GET(ecode,1);
940        }        }
941      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 895  for (;;) Line 959  for (;;)
959          {          {
960          eptr--;          eptr--;
961          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);          if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
962          BACKCHAR(eptr)          BACKCHAR(eptr);
963          }          }
964        }        }
965      else      else
# Line 1008  for (;;) Line 1072  for (;;)
1072              (pcre_free)(new_recursive.offset_save);              (pcre_free)(new_recursive.offset_save);
1073            RRETURN(MATCH_MATCH);            RRETURN(MATCH_MATCH);
1074            }            }
1075          else if (rrc != MATCH_NOMATCH)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
1076            {            {
1077            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1078            RRETURN(rrc);            RRETURN(rrc);
# Line 1044  for (;;) Line 1108  for (;;)
1108        {        {
1109        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7);
1110        if (rrc == MATCH_MATCH) break;        if (rrc == MATCH_MATCH) break;
1111        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1112        ecode += GET(ecode,1);        ecode += GET(ecode,1);
1113        }        }
1114      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
# Line 1110  for (;;) Line 1174  for (;;)
1174      do ecode += GET(ecode,1); while (*ecode == OP_ALT);      do ecode += GET(ecode,1); while (*ecode == OP_ALT);
1175      break;      break;
1176    
1177      /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating      /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
1178      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
1179      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
1180      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
1181      preceded by BRAZERO or BRAMINZERO. */      optional ones preceded by BRAZERO or BRAMINZERO. */
1182    
1183      case OP_BRAZERO:      case OP_BRAZERO:
1184        {        {
# Line 1136  for (;;) Line 1200  for (;;)
1200        }        }
1201      break;      break;
1202    
1203        case OP_SKIPZERO:
1204          {
1205          next = ecode+1;
1206          do next += GET(next,1); while (*next == OP_ALT);
1207          ecode = next + 1 + LINK_SIZE;
1208          }
1209        break;
1210    
1211      /* End of a group, repeated or non-repeating. */      /* End of a group, repeated or non-repeating. */
1212    
1213      case OP_KET:      case OP_KET:
# Line 1383  for (;;) Line 1455  for (;;)
1455      /* Match a single character type; inline for speed */      /* Match a single character type; inline for speed */
1456    
1457      case OP_ANY:      case OP_ANY:
1458      if ((ims & PCRE_DOTALL) == 0)      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
1459        {      /* Fall through */
1460        if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);  
1461        }      case OP_ALLANY:
1462      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
1463      if (utf8)      if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
       while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  
1464      ecode++;      ecode++;
1465      break;      break;
1466    
# Line 1488  for (;;) Line 1559  for (;;)
1559        case 0x000d:        case 0x000d:
1560        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
1561        break;        break;
1562    
1563        case 0x000a:        case 0x000a:
1564          break;
1565    
1566        case 0x000b:        case 0x000b:
1567        case 0x000c:        case 0x000c:
1568        case 0x0085:        case 0x0085:
1569        case 0x2028:        case 0x2028:
1570        case 0x2029:        case 0x2029:
1571          if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
1572        break;        break;
1573        }        }
1574      ecode++;      ecode++;
# Line 1604  for (;;) Line 1679  for (;;)
1679      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1680      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1681        {        {
1682        int chartype, script;        const ucd_record * prop = GET_UCD(c);
       int category = _pcre_ucp_findprop(c, &chartype, &script);  
1683    
1684        switch(ecode[1])        switch(ecode[1])
1685          {          {
# Line 1614  for (;;) Line 1688  for (;;)
1688          break;          break;
1689    
1690          case PT_LAMP:          case PT_LAMP:
1691          if ((chartype == ucp_Lu ||          if ((prop->chartype == ucp_Lu ||
1692               chartype == ucp_Ll ||               prop->chartype == ucp_Ll ||
1693               chartype == ucp_Lt) == (op == OP_NOTPROP))               prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
1694            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1695           break;           break;
1696    
1697          case PT_GC:          case PT_GC:
1698          if ((ecode[2] != category) == (op == OP_PROP))          if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP))
1699            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1700          break;          break;
1701    
1702          case PT_PC:          case PT_PC:
1703          if ((ecode[2] != chartype) == (op == OP_PROP))          if ((ecode[2] != prop->chartype) == (op == OP_PROP))
1704            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1705          break;          break;
1706    
1707          case PT_SC:          case PT_SC:
1708          if ((ecode[2] != script) == (op == OP_PROP))          if ((ecode[2] != prop->script) == (op == OP_PROP))
1709            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
1710          break;          break;
1711    
# Line 1650  for (;;) Line 1724  for (;;)
1724      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);      if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
1725      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
1726        {        {
1727        int chartype, script;        int category = UCD_CATEGORY(c);
       int category = _pcre_ucp_findprop(c, &chartype, &script);  
1728        if (category == ucp_M) RRETURN(MATCH_NOMATCH);        if (category == ucp_M) RRETURN(MATCH_NOMATCH);
1729        while (eptr < md->end_subject)        while (eptr < md->end_subject)
1730          {          {
# Line 1660  for (;;) Line 1733  for (;;)
1733            {            {
1734            GETCHARLEN(c, eptr, len);            GETCHARLEN(c, eptr, len);
1735            }            }
1736          category = _pcre_ucp_findprop(c, &chartype, &script);          category = UCD_CATEGORY(c);
1737          if (category != ucp_M) break;          if (category != ucp_M) break;
1738          eptr += len;          eptr += len;
1739          }          }
# Line 1681  for (;;) Line 1754  for (;;)
1754      case OP_REF:      case OP_REF:
1755        {        {
1756        offset = GET2(ecode, 1) << 1;               /* Doubled ref number */        offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
1757        ecode += 3;                                 /* Advance past item */        ecode += 3;
1758    
1759          /* If the reference is unset, there are two possibilities:
1760    
1761          (a) In the default, Perl-compatible state, set the length to be longer
1762          than the amount of subject left; this ensures that every attempt at a
1763          match fails. We can't just fail here, because of the possibility of
1764          quantifiers with zero minima.
1765    
1766          (b) If the JavaScript compatibility flag is set, set the length to zero
1767          so that the back reference matches an empty string.
1768    
1769          Otherwise, set the length to the length of what was matched by the
1770          referenced subpattern. */
1771    
1772        /* If the reference is unset, set the length to be longer than the amount        if (offset >= offset_top || md->offset_vector[offset] < 0)
1773        of subject left; this ensures that every attempt at a match fails. We          length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1;
1774        can't just fail here, because of the possibility of quantifiers with zero        else
1775        minima. */          length = md->offset_vector[offset+1] - md->offset_vector[offset];
   
       length = (offset >= offset_top || md->offset_vector[offset] < 0)?  
         md->end_subject - eptr + 1 :  
         md->offset_vector[offset+1] - md->offset_vector[offset];  
1776    
1777        /* Set up for repetition, or handle the non-repeated case */        /* Set up for repetition, or handle the non-repeated case */
1778    
# Line 2050  for (;;) Line 2132  for (;;)
2132            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21);
2133            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2134            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
2135            BACKCHAR(eptr)            if (utf8) BACKCHAR(eptr);
2136            }            }
2137          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2138          }          }
# Line 2116  for (;;) Line 2198  for (;;)
2198          if (fc != dc)          if (fc != dc)
2199            {            {
2200  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2201            if (dc != _pcre_ucp_othercase(fc))            if (dc != UCD_OTHERCASE(fc))
2202  #endif  #endif
2203              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2204            }            }
# Line 2207  for (;;) Line 2289  for (;;)
2289  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
2290          unsigned int othercase;          unsigned int othercase;
2291          if ((ims & PCRE_CASELESS) != 0 &&          if ((ims & PCRE_CASELESS) != 0 &&
2292              (othercase = _pcre_ucp_othercase(fc)) != NOTACHAR)              (othercase = UCD_OTHERCASE(fc)) != fc)
2293            oclength = _pcre_ord2utf8(othercase, occhars);            oclength = _pcre_ord2utf8(othercase, occhars);
2294          else oclength = 0;          else oclength = 0;
2295  #endif  /* SUPPORT_UCP */  #endif  /* SUPPORT_UCP */
# Line 2812  for (;;) Line 2894  for (;;)
2894              {              {
2895              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2896              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
2897              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
2898              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
2899                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
2900                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
# Line 2825  for (;;) Line 2907  for (;;)
2907              {              {
2908              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2909              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
2910              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
2911              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
2912                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2913              }              }
# Line 2836  for (;;) Line 2918  for (;;)
2918              {              {
2919              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2920              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
2921              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
2922              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
2923                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2924              }              }
# Line 2847  for (;;) Line 2929  for (;;)
2929              {              {
2930              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2931              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
2932              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_script = UCD_SCRIPT(c);
2933              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
2934                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2935              }              }
# Line 2866  for (;;) Line 2948  for (;;)
2948          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2949            {            {
2950            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2951            prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);            prop_category = UCD_CATEGORY(c);
2952            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
2953            while (eptr < md->end_subject)            while (eptr < md->end_subject)
2954              {              {
# Line 2875  for (;;) Line 2957  for (;;)
2957                {                {
2958                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
2959                }                }
2960              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
2961              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
2962              eptr += len;              eptr += len;
2963              }              }
# Line 2893  for (;;) Line 2975  for (;;)
2975          case OP_ANY:          case OP_ANY:
2976          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2977            {            {
2978            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject || IS_NEWLINE(eptr))
                ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))  
2979              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2980            eptr++;            eptr++;
2981            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
2982            }            }
2983          break;          break;
2984    
2985            case OP_ALLANY:
2986            for (i = 1; i <= min; i++)
2987              {
2988              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2989              eptr++;
2990              while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
2991              }
2992            break;
2993    
2994          case OP_ANYBYTE:          case OP_ANYBYTE:
2995          eptr += min;          eptr += min;
2996          break;          break;
# Line 2916  for (;;) Line 3006  for (;;)
3006              case 0x000d:              case 0x000d:
3007              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3008              break;              break;
3009    
3010              case 0x000a:              case 0x000a:
3011                break;
3012    
3013              case 0x000b:              case 0x000b:
3014              case 0x000c:              case 0x000c:
3015              case 0x0085:              case 0x0085:
3016              case 0x2028:              case 0x2028:
3017              case 0x2029:              case 0x2029:
3018                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3019              break;              break;
3020              }              }
3021            }            }
# Line 3055  for (;;) Line 3149  for (;;)
3149          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3150            {            {
3151            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3152               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
3153              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3154            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3155            }            }
3156          break;          break;
3157    
# Line 3075  for (;;) Line 3169  for (;;)
3169          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3170            {            {
3171            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3172               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))
3173              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3174            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3175            }            }
3176          break;          break;
3177    
# Line 3105  for (;;) Line 3199  for (;;)
3199        switch(ctype)        switch(ctype)
3200          {          {
3201          case OP_ANY:          case OP_ANY:
3202          if ((ims & PCRE_DOTALL) == 0)          for (i = 1; i <= min; i++)
3203            {            {
3204            for (i = 1; i <= min; i++)            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
3205              {            eptr++;
             if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);  
             eptr++;  
             }  
3206            }            }
3207          else eptr += min;          break;
3208    
3209            case OP_ALLANY:
3210            eptr += min;
3211          break;          break;
3212    
3213          case OP_ANYBYTE:          case OP_ANYBYTE:
# Line 3134  for (;;) Line 3228  for (;;)
3228              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3229              break;              break;
3230              case 0x000a:              case 0x000a:
3231                break;
3232    
3233              case 0x000b:              case 0x000b:
3234              case 0x000c:              case 0x000c:
3235              case 0x0085:              case 0x0085:
3236                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3237              break;              break;
3238              }              }
3239            }            }
# Line 3276  for (;;) Line 3373  for (;;)
3373              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3374              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3375              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3376              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3377              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3378                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3379                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
# Line 3291  for (;;) Line 3388  for (;;)
3388              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3389              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3390              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3391              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3392              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3393                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3394              }              }
# Line 3304  for (;;) Line 3401  for (;;)
3401              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3402              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3403              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3404              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3405              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3406                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3407              }              }
# Line 3317  for (;;) Line 3414  for (;;)
3414              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3415              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3416              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3417              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_script = UCD_SCRIPT(c);
3418              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3419                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3420              }              }
# Line 3339  for (;;) Line 3436  for (;;)
3436            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3437            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3438            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3439            prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);            prop_category = UCD_CATEGORY(c);
3440            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
3441            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3442              {              {
# Line 3348  for (;;) Line 3445  for (;;)
3445                {                {
3446                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3447                }                }
3448              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3449              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3450              eptr += len;              eptr += len;
3451              }              }
# Line 3367  for (;;) Line 3464  for (;;)
3464            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
3465            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3466            if (fi >= max || eptr >= md->end_subject ||            if (fi >= max || eptr >= md->end_subject ||
3467                 (ctype == OP_ANY && (ims & PCRE_DOTALL) == 0 &&                 (ctype == OP_ANY && IS_NEWLINE(eptr)))
                 IS_NEWLINE(eptr)))  
3468              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3469    
3470            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3471            switch(ctype)            switch(ctype)
3472              {              {
3473              case OP_ANY:        /* This is the DOTALL case */              case OP_ANY:        /* This is the non-NL case */
3474              break;              case OP_ALLANY:
   
3475              case OP_ANYBYTE:              case OP_ANYBYTE:
3476              break;              break;
3477    
# Line 3388  for (;;) Line 3483  for (;;)
3483                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3484                break;                break;
3485                case 0x000a:                case 0x000a:
3486                  break;
3487    
3488                case 0x000b:                case 0x000b:
3489                case 0x000c:                case 0x000c:
3490                case 0x0085:                case 0x0085:
3491                case 0x2028:                case 0x2028:
3492                case 0x2029:                case 0x2029:
3493                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3494                break;                break;
3495                }                }
3496              break;              break;
# Line 3525  for (;;) Line 3623  for (;;)
3623            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
3624            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3625            if (fi >= max || eptr >= md->end_subject ||            if (fi >= max || eptr >= md->end_subject ||
3626                 ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))                 (ctype == OP_ANY && IS_NEWLINE(eptr)))
3627              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3628    
3629            c = *eptr++;            c = *eptr++;
3630            switch(ctype)            switch(ctype)
3631              {              {
3632              case OP_ANY:   /* This is the DOTALL case */              case OP_ANY:     /* This is the non-NL case */
3633              break;              case OP_ALLANY:
   
3634              case OP_ANYBYTE:              case OP_ANYBYTE:
3635              break;              break;
3636    
# Line 3544  for (;;) Line 3641  for (;;)
3641                case 0x000d:                case 0x000d:
3642                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3643                break;                break;
3644    
3645                case 0x000a:                case 0x000a:
3646                  break;
3647    
3648                case 0x000b:                case 0x000b:
3649                case 0x000c:                case 0x000c:
3650                case 0x0085:                case 0x0085:
3651                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3652                break;                break;
3653                }                }
3654              break;              break;
# Line 3662  for (;;) Line 3763  for (;;)
3763              int len = 1;              int len = 1;
3764              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3765              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3766              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3767              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3768                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3769                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
# Line 3677  for (;;) Line 3778  for (;;)
3778              int len = 1;              int len = 1;
3779              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3780              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3781              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3782              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3783                break;                break;
3784              eptr+= len;              eptr+= len;
# Line 3690  for (;;) Line 3791  for (;;)
3791              int len = 1;              int len = 1;
3792              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3793              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3794              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3795              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3796                break;                break;
3797              eptr+= len;              eptr+= len;
# Line 3703  for (;;) Line 3804  for (;;)
3804              int len = 1;              int len = 1;
3805              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3806              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3807              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_script = UCD_SCRIPT(c);
3808              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3809                break;                break;
3810              eptr+= len;              eptr+= len;
# Line 3719  for (;;) Line 3820  for (;;)
3820            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);
3821            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3822            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3823            BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
3824            }            }
3825          }          }
3826    
# Line 3732  for (;;) Line 3833  for (;;)
3833            {            {
3834            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject) break;
3835            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3836            prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);            prop_category = UCD_CATEGORY(c);
3837            if (prop_category == ucp_M) break;            if (prop_category == ucp_M) break;
3838            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3839              {              {
# Line 3741  for (;;) Line 3842  for (;;)
3842                {                {
3843                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3844                }                }
3845              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3846              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3847              eptr += len;              eptr += len;
3848              }              }
# Line 3758  for (;;) Line 3859  for (;;)
3859            for (;;)                        /* Move back over one extended */            for (;;)                        /* Move back over one extended */
3860              {              {
3861              int len = 1;              int len = 1;
             BACKCHAR(eptr);  
3862              if (!utf8) c = *eptr; else              if (!utf8) c = *eptr; else
3863                {                {
3864                  BACKCHAR(eptr);
3865                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3866                }                }
3867              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3868              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3869              eptr--;              eptr--;
3870              }              }
# Line 3783  for (;;) Line 3884  for (;;)
3884            case OP_ANY:            case OP_ANY:
3885            if (max < INT_MAX)            if (max < INT_MAX)
3886              {              {
3887              if ((ims & PCRE_DOTALL) == 0)              for (i = min; i < max; i++)
               {  
               for (i = min; i < max; i++)  
                 {  
                 if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;  
                 eptr++;  
                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  
                 }  
               }  
             else  
3888                {                {
3889                for (i = min; i < max; i++)                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
3890                  {                eptr++;
3891                  if (eptr >= md->end_subject) break;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                 eptr++;  
                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  
                 }  
3892                }                }
3893              }              }
3894    
# Line 3807  for (;;) Line 3896  for (;;)
3896    
3897            else            else
3898              {              {
3899              if ((ims & PCRE_DOTALL) == 0)              for (i = min; i < max; i++)
3900                {                {
3901                for (i = min; i < max; i++)                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
3902                  {                eptr++;
3903                  if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
                 eptr++;  
                 while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;  
                 }  
3904                }                }
3905              else              }
3906              break;
3907    
3908              case OP_ALLANY:
3909              if (max < INT_MAX)
3910                {
3911                for (i = min; i < max; i++)
3912                {                {
3913                eptr = md->end_subject;                if (eptr >= md->end_subject) break;
3914                  eptr++;
3915                  while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3916                }                }
3917              }              }
3918              else eptr = md->end_subject;   /* Unlimited UTF-8 repeat */
3919            break;            break;
3920    
3921            /* The byte case is the same as non-UTF8 */            /* The byte case is the same as non-UTF8 */
# Line 3845  for (;;) Line 3940  for (;;)
3940                }                }
3941              else              else
3942                {                {
3943                if (c != 0x000a && c != 0x000b && c != 0x000c &&                if (c != 0x000a &&
3944                    c != 0x0085 && c != 0x2028 && c != 0x2029)                    (md->bsr_anycrlf ||
3945                       (c != 0x000b && c != 0x000c &&
3946                        c != 0x0085 && c != 0x2028 && c != 0x2029)))
3947                  break;                  break;
3948                eptr += len;                eptr += len;
3949                }                }
# Line 3999  for (;;) Line 4096  for (;;)
4096            }            }
4097          }          }
4098        else        else
4099  #endif  #endif  /* SUPPORT_UTF8 */
4100    
4101        /* Not UTF-8 mode */        /* Not UTF-8 mode */
4102          {          {
4103          switch(ctype)          switch(ctype)
4104            {            {
4105            case OP_ANY:            case OP_ANY:
4106            if ((ims & PCRE_DOTALL) == 0)            for (i = min; i < max; i++)
4107              {              {
4108              for (i = min; i < max; i++)              if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
4109                {              eptr++;
               if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;  
               eptr++;  
               }  
             break;  
4110              }              }
4111            /* For DOTALL case, fall through and treat as \C */            break;
4112    
4113              case OP_ALLANY:
4114            case OP_ANYBYTE:            case OP_ANYBYTE:
4115            c = max - min;            c = max - min;
4116            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
# Line 4036  for (;;) Line 4130  for (;;)
4130                }                }
4131              else              else
4132                {                {
4133                if (c != 0x000a && c != 0x000b && c != 0x000c && c != 0x0085)                if (c != 0x000a &&
4134                      (md->bsr_anycrlf ||
4135                        (c != 0x000b && c != 0x000c && c != 0x0085)))
4136                  break;                  break;
4137                eptr++;                eptr++;
4138                }                }
# Line 4186  HEAP_RETURN: Line 4282  HEAP_RETURN:
4282  switch (frame->Xwhere)  switch (frame->Xwhere)
4283    {    {
4284    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)
4285    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)
4286    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)
4287    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)
4288    LBL(33) LBL(34) LBL(35) LBL(36) LBL(37) LBL(38) LBL(39) LBL(40)    LBL(53) LBL(54)
4289    LBL(41) LBL(42) LBL(43) LBL(44) LBL(45) LBL(46) LBL(47)  #ifdef SUPPORT_UTF8
4290      LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
4291      LBL(32) LBL(34) LBL(42) LBL(46)
4292    #ifdef SUPPORT_UCP
4293      LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
4294    #endif  /* SUPPORT_UCP */
4295    #endif  /* SUPPORT_UTF8 */
4296    default:    default:
4297    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));
4298    return PCRE_ERROR_INTERNAL;    return PCRE_ERROR_INTERNAL;
# Line 4282  Returns: > 0 => success; value Line 4384  Returns: > 0 => success; value
4384                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
4385  */  */
4386    
4387  PCRE_EXP_DEFN int  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
4388  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
4389    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
4390    int offsetcount)    int offsetcount)
# Line 4369  if (re->magic_number != MAGIC_NUMBER) Line 4471  if (re->magic_number != MAGIC_NUMBER)
4471  /* Set up other data */  /* Set up other data */
4472    
4473  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
4474  startline = (re->options & PCRE_STARTLINE) != 0;  startline = (re->flags & PCRE_STARTLINE) != 0;
4475  firstline = (re->options & PCRE_FIRSTLINE) != 0;  firstline = (re->options & PCRE_FIRSTLINE) != 0;
4476    
4477  /* 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 4384  end_subject = md->end_subject; Line 4486  end_subject = md->end_subject;
4486    
4487  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
4488  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
4489    md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
4490    
4491  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
4492  md->noteol = (options & PCRE_NOTEOL) != 0;  md->noteol = (options & PCRE_NOTEOL) != 0;
# Line 4396  md->recursive = NULL; Line 4499  md->recursive = NULL;
4499  md->lcc = tables + lcc_offset;  md->lcc = tables + lcc_offset;
4500  md->ctypes = tables + ctypes_offset;  md->ctypes = tables + ctypes_offset;
4501    
4502    /* Handle different \R options. */
4503    
4504    switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
4505      {
4506      case 0:
4507      if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
4508        md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
4509      else
4510    #ifdef BSR_ANYCRLF
4511      md->bsr_anycrlf = TRUE;
4512    #else
4513      md->bsr_anycrlf = FALSE;
4514    #endif
4515      break;
4516    
4517      case PCRE_BSR_ANYCRLF:
4518      md->bsr_anycrlf = TRUE;
4519      break;
4520    
4521      case PCRE_BSR_UNICODE:
4522      md->bsr_anycrlf = FALSE;
4523      break;
4524    
4525      default: return PCRE_ERROR_BADNEWLINE;
4526      }
4527    
4528  /* Handle different types of newline. The three bits give eight cases. If  /* Handle different types of newline. The three bits give eight cases. If
4529  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. */
4530    
4531  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
4532         PCRE_NEWLINE_BITS)          (pcre_uint32)options) & PCRE_NEWLINE_BITS)
4533    {    {
4534    case 0: newline = NEWLINE; break;   /* Compile-time default */    case 0: newline = NEWLINE; break;   /* Compile-time default */
4535    case PCRE_NEWLINE_CR: newline = '\r'; break;    case PCRE_NEWLINE_CR: newline = '\r'; break;
# Line 4439  else Line 4568  else
4568  /* 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
4569  moment. */  moment. */
4570    
4571  if (md->partial && (re->options & PCRE_NOPARTIAL) != 0)  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
4572    return PCRE_ERROR_BADPARTIAL;    return PCRE_ERROR_BADPARTIAL;
4573    
4574  /* 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 4516  studied, there may be a bitmap of possib Line 4645  studied, there may be a bitmap of possib
4645    
4646  if (!anchored)  if (!anchored)
4647    {    {
4648    if ((re->options & PCRE_FIRSTSET) != 0)    if ((re->flags & PCRE_FIRSTSET) != 0)
4649      {      {
4650      first_byte = re->first_byte & 255;      first_byte = re->first_byte & 255;
4651      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)      if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
# Line 4531  if (!anchored) Line 4660  if (!anchored)
4660  /* For anchored or unanchored matches, there may be a "last known required  /* For anchored or unanchored matches, there may be a "last known required
4661  character" set. */  character" set. */
4662    
4663  if ((re->options & PCRE_REQCHSET) != 0)  if ((re->flags & PCRE_REQCHSET) != 0)
4664    {    {
4665    req_byte = re->req_byte & 255;    req_byte = re->req_byte & 255;
4666    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
# Line 4547  the loop runs just once. */ Line 4676  the loop runs just once. */
4676  for(;;)  for(;;)
4677    {    {
4678    USPTR save_end_subject = end_subject;    USPTR save_end_subject = end_subject;
4679      USPTR new_start_match;
4680    
4681    /* Reset the maximum number of extractions we might see. */    /* Reset the maximum number of extractions we might see. */
4682    
# Line 4566  for(;;) Line 4696  for(;;)
4696    if (firstline)    if (firstline)
4697      {      {
4698      USPTR t = start_match;      USPTR t = start_match;
4699    #ifdef SUPPORT_UTF8
4700        if (utf8)
4701          {
4702          while (t < md->end_subject && !IS_NEWLINE(t))
4703            {
4704            t++;
4705            while (t < end_subject && (*t & 0xc0) == 0x80) t++;
4706            }
4707          }
4708        else
4709    #endif
4710      while (t < md->end_subject && !IS_NEWLINE(t)) t++;      while (t < md->end_subject && !IS_NEWLINE(t)) t++;
4711      end_subject = t;      end_subject = t;
4712      }      }
4713    
4714    /* Now test for a unique first byte */    /* Now advance to a unique first byte if there is one. */
4715    
4716    if (first_byte >= 0)    if (first_byte >= 0)
4717      {      {
4718      if (first_byte_caseless)      if (first_byte_caseless)
4719        while (start_match < end_subject &&        while (start_match < end_subject && md->lcc[*start_match] != first_byte)
              md->lcc[*start_match] != first_byte)  
4720          start_match++;          start_match++;
4721      else      else
4722        while (start_match < end_subject && *start_match != first_byte)        while (start_match < end_subject && *start_match != first_byte)
4723          start_match++;          start_match++;
4724      }      }
4725    
4726    /* Or to just after a linebreak for a multiline match if possible */    /* Or to just after a linebreak for a multiline match */
4727    
4728    else if (startline)    else if (startline)
4729      {      {
4730      if (start_match > md->start_subject + start_offset)      if (start_match > md->start_subject + start_offset)
4731        {        {
4732        while (start_match <= end_subject && !WAS_NEWLINE(start_match))  #ifdef SUPPORT_UTF8
4733          if (utf8)
4734            {
4735            while (start_match < end_subject && !WAS_NEWLINE(start_match))
4736              {
4737              start_match++;
4738              while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
4739                start_match++;
4740              }
4741            }
4742          else
4743    #endif
4744          while (start_match < end_subject && !WAS_NEWLINE(start_match))
4745          start_match++;          start_match++;
4746    
4747        /* 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,
4748        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.
4749        */        */
# Line 4604  for(;;) Line 4756  for(;;)
4756        }        }
4757      }      }
4758    
4759    /* Or to a non-unique first char after study */    /* Or to a non-unique first byte after study */
4760    
4761    else if (start_bits != NULL)    else if (start_bits != NULL)
4762      {      {
4763      while (start_match < end_subject)      while (start_match < end_subject)
4764        {        {
4765        register unsigned int c = *start_match;        register unsigned int c = *start_match;
4766        if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break;        if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++;
4767            else break;
4768        }        }
4769      }      }
4770    
# Line 4686  for(;;) Line 4839  for(;;)
4839      }      }
4840    
4841    /* OK, we can now run the match. */    /* OK, we can now run the match. */
4842    
4843    md->start_match_ptr = start_match;      /* Insurance */    md->start_match_ptr = start_match;
4844    md->match_call_count = 0;    md->match_call_count = 0;
4845    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);
4846    
4847    /* Any return other than MATCH_NOMATCH breaks the loop. */    switch(rc)
4848        {
4849        /* NOMATCH and PRUNE advance by one character. THEN at this level acts
4850        exactly like PRUNE. */
4851    
4852        case MATCH_NOMATCH:
4853        case MATCH_PRUNE:
4854        case MATCH_THEN:
4855        new_start_match = start_match + 1;
4856    #ifdef SUPPORT_UTF8
4857        if (utf8)
4858          while(new_start_match < end_subject && (*new_start_match & 0xc0) == 0x80)
4859            new_start_match++;
4860    #endif
4861        break;
4862    
4863        /* SKIP passes back the next starting point explicitly. */
4864    
4865        case MATCH_SKIP:
4866        new_start_match = md->start_match_ptr;
4867        break;
4868    
4869        /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
4870    
4871    if (rc != MATCH_NOMATCH) break;      case MATCH_COMMIT:
4872        rc = MATCH_NOMATCH;
4873        goto ENDLOOP;
4874    
4875        /* Any other return is some kind of error. */
4876    
4877        default:
4878        goto ENDLOOP;
4879        }
4880    
4881      /* Control reaches here for the various types of "no match at this point"
4882      result. Reset the code to MATCH_NOMATCH for subsequent checking. */
4883    
4884      rc = MATCH_NOMATCH;
4885    
4886    /* 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
4887    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 4701  for(;;) Line 4889  for(;;)
4889    
4890    if (firstline && IS_NEWLINE(start_match)) break;    if (firstline && IS_NEWLINE(start_match)) break;
4891    
4892    /* Advance the match position by one character. */    /* Advance to new matching position */
4893    
4894    start_match++;    start_match = new_start_match;
 #ifdef SUPPORT_UTF8  
   if (utf8)  
     while(start_match < end_subject && (*start_match & 0xc0) == 0x80)  
       start_match++;  
 #endif  
4895    
4896    /* Break the loop if the pattern is anchored or if we have passed the end of    /* Break the loop if the pattern is anchored or if we have passed the end of
4897    the subject. */    the subject. */
4898    
4899    if (anchored || start_match > end_subject) break;    if (anchored || start_match > end_subject) break;
4900    
4901    /* 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
4902    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
4903    character. */    or ANY or ANYCRLF, advance the match position by one more character. */
4904    
4905    if (start_match[-1] == '\r' &&    if (start_match[-1] == '\r' &&
4906         (md->nltype == NLTYPE_ANY ||        start_match < end_subject &&
4907          md->nltype == NLTYPE_ANYCRLF ||        *start_match == '\n' &&
4908          md->nllen == 2) &&        (re->flags & PCRE_HASCRORLF) == 0 &&
4909         start_match < end_subject &&          (md->nltype == NLTYPE_ANY ||
4910         *start_match == '\n')           md->nltype == NLTYPE_ANYCRLF ||
4911             md->nllen == 2))
4912      start_match++;      start_match++;
4913    
4914    }   /* End of for(;;) "bumpalong" loop */    }   /* End of for(;;) "bumpalong" loop */
# Line 4734  for(;;) Line 4918  for(;;)
4918  /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping  /* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
4919  conditions is true:  conditions is true:
4920    
4921  (1) The pattern is anchored;  (1) The pattern is anchored or the match was failed by (*COMMIT);
4922    
4923  (2) We are past the end of the subject;  (2) We are past the end of the subject;
4924    
# Line 4749  processing, copy those that we can. In t Line 4933  processing, copy those that we can. In t
4933  certain parts of the pattern were not used, even though there are more  certain parts of the pattern were not used, even though there are more
4934  capturing parentheses than vector slots. */  capturing parentheses than vector slots. */
4935    
4936    ENDLOOP:
4937    
4938  if (rc == MATCH_MATCH)  if (rc == MATCH_MATCH)
4939    {    {
4940    if (using_temporary_offsets)    if (using_temporary_offsets)
Legend:
Removed from v.199  
changed lines
  Added in v.365
webmaster@exim.org
 ViewVC Help
Powered by ViewVC 1.1.12