/[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 200 by ph10, Wed Aug 1 09:10:40 2007 UTC revision 366 by ph10, Mon Jul 14 15:45:32 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
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        /* If the reference is unset, set the length to be longer than the amount        (a) In the default, Perl-compatible state, set the length to be longer
1762        of subject left; this ensures that every attempt at a match fails. We        than the amount of subject left; this ensures that every attempt at a
1763        can't just fail here, because of the possibility of quantifiers with zero        match fails. We can't just fail here, because of the possibility of
1764        minima. */        quantifiers with zero minima.
1765    
1766        length = (offset >= offset_top || md->offset_vector[offset] < 0)?        (b) If the JavaScript compatibility flag is set, set the length to zero
1767          md->end_subject - eptr + 1 :        so that the back reference matches an empty string.
1768          md->offset_vector[offset+1] - md->offset_vector[offset];  
1769          Otherwise, set the length to the length of what was matched by the
1770          referenced subpattern. */
1771    
1772          if (offset >= offset_top || md->offset_vector[offset] < 0)
1773            length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1;
1774          else
1775            length = 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 2527  for (;;) Line 2609  for (;;)
2609              {              {
2610              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28);
2611              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2612                if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2613              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
2614              if (d < 256) d = md->lcc[d];              if (d < 256) d = md->lcc[d];
2615              if (fi >= max || eptr >= md->end_subject || fc == d)              if (fc == d) RRETURN(MATCH_NOMATCH);
2616                RRETURN(MATCH_NOMATCH);  
2617              }              }
2618            }            }
2619          else          else
# Line 2636  for (;;) Line 2719  for (;;)
2719              {              {
2720              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);              RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32);
2721              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
2722                if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2723              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
2724              if (fi >= max || eptr >= md->end_subject || fc == d)              if (fc == d) RRETURN(MATCH_NOMATCH);
               RRETURN(MATCH_NOMATCH);  
2725              }              }
2726            }            }
2727          else          else
# Line 2812  for (;;) Line 2895  for (;;)
2895              {              {
2896              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2897              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
2898              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
2899              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
2900                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
2901                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
# Line 2825  for (;;) Line 2908  for (;;)
2908              {              {
2909              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2910              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
2911              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
2912              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
2913                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2914              }              }
# Line 2836  for (;;) Line 2919  for (;;)
2919              {              {
2920              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2921              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
2922              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
2923              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
2924                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2925              }              }
# Line 2847  for (;;) Line 2930  for (;;)
2930              {              {
2931              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2932              GETCHARINCTEST(c, eptr);              GETCHARINCTEST(c, eptr);
2933              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_script = UCD_SCRIPT(c);
2934              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
2935                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
2936              }              }
# Line 2866  for (;;) Line 2949  for (;;)
2949          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2950            {            {
2951            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
2952            prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);            prop_category = UCD_CATEGORY(c);
2953            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
2954            while (eptr < md->end_subject)            while (eptr < md->end_subject)
2955              {              {
# Line 2875  for (;;) Line 2958  for (;;)
2958                {                {
2959                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
2960                }                }
2961              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
2962              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
2963              eptr += len;              eptr += len;
2964              }              }
# Line 2893  for (;;) Line 2976  for (;;)
2976          case OP_ANY:          case OP_ANY:
2977          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
2978            {            {
2979            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject || IS_NEWLINE(eptr))
                ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))  
2980              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
2981            eptr++;            eptr++;
2982            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
2983            }            }
2984          break;          break;
2985    
2986            case OP_ALLANY:
2987            for (i = 1; i <= min; i++)
2988              {
2989              if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
2990              eptr++;
2991              while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
2992              }
2993            break;
2994    
2995          case OP_ANYBYTE:          case OP_ANYBYTE:
2996          eptr += min;          eptr += min;
2997          break;          break;
# Line 2916  for (;;) Line 3007  for (;;)
3007              case 0x000d:              case 0x000d:
3008              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3009              break;              break;
3010    
3011              case 0x000a:              case 0x000a:
3012                break;
3013    
3014              case 0x000b:              case 0x000b:
3015              case 0x000c:              case 0x000c:
3016              case 0x0085:              case 0x0085:
3017              case 0x2028:              case 0x2028:
3018              case 0x2029:              case 0x2029:
3019                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3020              break;              break;
3021              }              }
3022            }            }
# Line 3055  for (;;) Line 3150  for (;;)
3150          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3151            {            {
3152            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3153               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0))
3154              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3155            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3156            }            }
3157          break;          break;
3158    
# Line 3075  for (;;) Line 3170  for (;;)
3170          for (i = 1; i <= min; i++)          for (i = 1; i <= min; i++)
3171            {            {
3172            if (eptr >= md->end_subject ||            if (eptr >= md->end_subject ||
3173               (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))               (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0))
3174              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3175            while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;            while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80);
3176            }            }
3177          break;          break;
3178    
# Line 3105  for (;;) Line 3200  for (;;)
3200        switch(ctype)        switch(ctype)
3201          {          {
3202          case OP_ANY:          case OP_ANY:
3203          if ((ims & PCRE_DOTALL) == 0)          for (i = 1; i <= min; i++)
3204            {            {
3205            for (i = 1; i <= min; i++)            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
3206              {            eptr++;
             if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);  
             eptr++;  
             }  
3207            }            }
3208          else eptr += min;          break;
3209    
3210            case OP_ALLANY:
3211            eptr += min;
3212          break;          break;
3213    
3214          case OP_ANYBYTE:          case OP_ANYBYTE:
# Line 3134  for (;;) Line 3229  for (;;)
3229              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3230              break;              break;
3231              case 0x000a:              case 0x000a:
3232                break;
3233    
3234              case 0x000b:              case 0x000b:
3235              case 0x000c:              case 0x000c:
3236              case 0x0085:              case 0x0085:
3237                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3238              break;              break;
3239              }              }
3240            }            }
# Line 3276  for (;;) Line 3374  for (;;)
3374              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3375              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3376              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3377              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3378              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3379                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3380                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
# Line 3291  for (;;) Line 3389  for (;;)
3389              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3390              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3391              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3392              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3393              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3394                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3395              }              }
# Line 3304  for (;;) Line 3402  for (;;)
3402              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3403              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3404              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3405              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3406              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3407                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3408              }              }
# Line 3317  for (;;) Line 3415  for (;;)
3415              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3416              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);              if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3417              GETCHARINC(c, eptr);              GETCHARINC(c, eptr);
3418              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_script = UCD_SCRIPT(c);
3419              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3420                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3421              }              }
# Line 3339  for (;;) Line 3437  for (;;)
3437            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3438            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
3439            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3440            prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);            prop_category = UCD_CATEGORY(c);
3441            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);            if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
3442            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3443              {              {
# Line 3348  for (;;) Line 3446  for (;;)
3446                {                {
3447                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3448                }                }
3449              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3450              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3451              eptr += len;              eptr += len;
3452              }              }
# Line 3367  for (;;) Line 3465  for (;;)
3465            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42);
3466            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3467            if (fi >= max || eptr >= md->end_subject ||            if (fi >= max || eptr >= md->end_subject ||
3468                 (ctype == OP_ANY && (ims & PCRE_DOTALL) == 0 &&                 (ctype == OP_ANY && IS_NEWLINE(eptr)))
                 IS_NEWLINE(eptr)))  
3469              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3470    
3471            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
3472            switch(ctype)            switch(ctype)
3473              {              {
3474              case OP_ANY:        /* This is the DOTALL case */              case OP_ANY:        /* This is the non-NL case */
3475              break;              case OP_ALLANY:
   
3476              case OP_ANYBYTE:              case OP_ANYBYTE:
3477              break;              break;
3478    
# Line 3388  for (;;) Line 3484  for (;;)
3484                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3485                break;                break;
3486                case 0x000a:                case 0x000a:
3487                  break;
3488    
3489                case 0x000b:                case 0x000b:
3490                case 0x000c:                case 0x000c:
3491                case 0x0085:                case 0x0085:
3492                case 0x2028:                case 0x2028:
3493                case 0x2029:                case 0x2029:
3494                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3495                break;                break;
3496                }                }
3497              break;              break;
# Line 3525  for (;;) Line 3624  for (;;)
3624            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43);
3625            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3626            if (fi >= max || eptr >= md->end_subject ||            if (fi >= max || eptr >= md->end_subject ||
3627                 ((ims & PCRE_DOTALL) == 0 && IS_NEWLINE(eptr)))                 (ctype == OP_ANY && IS_NEWLINE(eptr)))
3628              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3629    
3630            c = *eptr++;            c = *eptr++;
3631            switch(ctype)            switch(ctype)
3632              {              {
3633              case OP_ANY:   /* This is the DOTALL case */              case OP_ANY:     /* This is the non-NL case */
3634              break;              case OP_ALLANY:
   
3635              case OP_ANYBYTE:              case OP_ANYBYTE:
3636              break;              break;
3637    
# Line 3544  for (;;) Line 3642  for (;;)
3642                case 0x000d:                case 0x000d:
3643                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;
3644                break;                break;
3645    
3646                case 0x000a:                case 0x000a:
3647                  break;
3648    
3649                case 0x000b:                case 0x000b:
3650                case 0x000c:                case 0x000c:
3651                case 0x0085:                case 0x0085:
3652                  if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
3653                break;                break;
3654                }                }
3655              break;              break;
# Line 3662  for (;;) Line 3764  for (;;)
3764              int len = 1;              int len = 1;
3765              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3766              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3767              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3768              if ((prop_chartype == ucp_Lu ||              if ((prop_chartype == ucp_Lu ||
3769                   prop_chartype == ucp_Ll ||                   prop_chartype == ucp_Ll ||
3770                   prop_chartype == ucp_Lt) == prop_fail_result)                   prop_chartype == ucp_Lt) == prop_fail_result)
# Line 3677  for (;;) Line 3779  for (;;)
3779              int len = 1;              int len = 1;
3780              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3781              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3782              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3783              if ((prop_category == prop_value) == prop_fail_result)              if ((prop_category == prop_value) == prop_fail_result)
3784                break;                break;
3785              eptr+= len;              eptr+= len;
# Line 3690  for (;;) Line 3792  for (;;)
3792              int len = 1;              int len = 1;
3793              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3794              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3795              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_chartype = UCD_CHARTYPE(c);
3796              if ((prop_chartype == prop_value) == prop_fail_result)              if ((prop_chartype == prop_value) == prop_fail_result)
3797                break;                break;
3798              eptr+= len;              eptr+= len;
# Line 3703  for (;;) Line 3805  for (;;)
3805              int len = 1;              int len = 1;
3806              if (eptr >= md->end_subject) break;              if (eptr >= md->end_subject) break;
3807              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
3808              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_script = UCD_SCRIPT(c);
3809              if ((prop_script == prop_value) == prop_fail_result)              if ((prop_script == prop_value) == prop_fail_result)
3810                break;                break;
3811              eptr+= len;              eptr+= len;
# Line 3719  for (;;) Line 3821  for (;;)
3821            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);            RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM44);
3822            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
3823            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
3824            BACKCHAR(eptr);            if (utf8) BACKCHAR(eptr);
3825            }            }
3826          }          }
3827    
# Line 3732  for (;;) Line 3834  for (;;)
3834            {            {
3835            if (eptr >= md->end_subject) break;            if (eptr >= md->end_subject) break;
3836            GETCHARINCTEST(c, eptr);            GETCHARINCTEST(c, eptr);
3837            prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);            prop_category = UCD_CATEGORY(c);
3838            if (prop_category == ucp_M) break;            if (prop_category == ucp_M) break;
3839            while (eptr < md->end_subject)            while (eptr < md->end_subject)
3840              {              {
# Line 3741  for (;;) Line 3843  for (;;)
3843                {                {
3844                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3845                }                }
3846              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3847              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3848              eptr += len;              eptr += len;
3849              }              }
# Line 3758  for (;;) Line 3860  for (;;)
3860            for (;;)                        /* Move back over one extended */            for (;;)                        /* Move back over one extended */
3861              {              {
3862              int len = 1;              int len = 1;
             BACKCHAR(eptr);  
3863              if (!utf8) c = *eptr; else              if (!utf8) c = *eptr; else
3864                {                {
3865                  BACKCHAR(eptr);
3866                GETCHARLEN(c, eptr, len);                GETCHARLEN(c, eptr, len);
3867                }                }
3868              prop_category = _pcre_ucp_findprop(c, &prop_chartype, &prop_script);              prop_category = UCD_CATEGORY(c);
3869              if (prop_category != ucp_M) break;              if (prop_category != ucp_M) break;
3870              eptr--;              eptr--;
3871              }              }
# Line 3783  for (;;) Line 3885  for (;;)
3885            case OP_ANY:            case OP_ANY:
3886            if (max < INT_MAX)            if (max < INT_MAX)
3887              {              {
3888              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  
3889                {                {
3890                for (i = min; i < max; i++)                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
3891                  {                eptr++;
3892                  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++;  
                 }  
3893                }                }
3894              }              }
3895    
# Line 3807  for (;;) Line 3897  for (;;)
3897    
3898            else            else
3899              {              {
3900              if ((ims & PCRE_DOTALL) == 0)              for (i = min; i < max; i++)
3901                {                {
3902                for (i = min; i < max; i++)                if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
3903                  {                eptr++;
3904                  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++;  
                 }  
3905                }                }
3906              else              }
3907              break;
3908    
3909              case OP_ALLANY:
3910              if (max < INT_MAX)
3911                {
3912                for (i = min; i < max; i++)
3913                {                {
3914                eptr = md->end_subject;                if (eptr >= md->end_subject) break;
3915                  eptr++;
3916                  while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
3917                }                }
3918              }              }
3919              else eptr = md->end_subject;   /* Unlimited UTF-8 repeat */
3920            break;            break;
3921    
3922            /* The byte case is the same as non-UTF8 */            /* The byte case is the same as non-UTF8 */
# Line 3845  for (;;) Line 3941  for (;;)
3941                }                }
3942              else              else
3943                {                {
3944                if (c != 0x000a && c != 0x000b && c != 0x000c &&                if (c != 0x000a &&
3945                    c != 0x0085 && c != 0x2028 && c != 0x2029)                    (md->bsr_anycrlf ||
3946                       (c != 0x000b && c != 0x000c &&
3947                        c != 0x0085 && c != 0x2028 && c != 0x2029)))
3948                  break;                  break;
3949                eptr += len;                eptr += len;
3950                }                }
# Line 3999  for (;;) Line 4097  for (;;)
4097            }            }
4098          }          }
4099        else        else
4100  #endif  #endif  /* SUPPORT_UTF8 */
4101    
4102        /* Not UTF-8 mode */        /* Not UTF-8 mode */
4103          {          {
4104          switch(ctype)          switch(ctype)
4105            {            {
4106            case OP_ANY:            case OP_ANY:
4107            if ((ims & PCRE_DOTALL) == 0)            for (i = min; i < max; i++)
4108              {              {
4109              for (i = min; i < max; i++)              if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;
4110                {              eptr++;
               if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break;  
               eptr++;  
               }  
             break;  
4111              }              }
4112            /* For DOTALL case, fall through and treat as \C */            break;
4113    
4114              case OP_ALLANY:
4115            case OP_ANYBYTE:            case OP_ANYBYTE:
4116            c = max - min;            c = max - min;
4117            if (c > (unsigned int)(md->end_subject - eptr))            if (c > (unsigned int)(md->end_subject - eptr))
# Line 4036  for (;;) Line 4131  for (;;)
4131                }                }
4132              else              else
4133                {                {
4134                if (c != 0x000a && c != 0x000b && c != 0x000c && c != 0x0085)                if (c != 0x000a &&
4135                      (md->bsr_anycrlf ||
4136                        (c != 0x000b && c != 0x000c && c != 0x0085)))
4137                  break;                  break;
4138                eptr++;                eptr++;
4139                }                }
# Line 4186  HEAP_RETURN: Line 4283  HEAP_RETURN:
4283  switch (frame->Xwhere)  switch (frame->Xwhere)
4284    {    {
4285    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)
4286    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)
4287    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)
4288    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)
4289    LBL(33) LBL(34) LBL(35) LBL(36) LBL(37) LBL(38) LBL(39) LBL(40)    LBL(53) LBL(54)
4290    LBL(41) LBL(42) LBL(43) LBL(44) LBL(45) LBL(46) LBL(47)  #ifdef SUPPORT_UTF8
4291      LBL(16) LBL(18) LBL(20) LBL(21) LBL(22) LBL(23) LBL(28) LBL(30)
4292      LBL(32) LBL(34) LBL(42) LBL(46)
4293    #ifdef SUPPORT_UCP
4294      LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
4295    #endif  /* SUPPORT_UCP */
4296    #endif  /* SUPPORT_UTF8 */
4297    default:    default:
4298    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));
4299    return PCRE_ERROR_INTERNAL;    return PCRE_ERROR_INTERNAL;
# Line 4282  Returns:          > 0 => success; value Line 4385  Returns:          > 0 => success; value
4385                   < -1 => some kind of unexpected problem                   < -1 => some kind of unexpected problem
4386  */  */
4387    
4388  PCRE_EXP_DEFN int  PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
4389  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,  pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
4390    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,    PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
4391    int offsetcount)    int offsetcount)
# Line 4369  if (re->magic_number != MAGIC_NUMBER) Line 4472  if (re->magic_number != MAGIC_NUMBER)
4472  /* Set up other data */  /* Set up other data */
4473    
4474  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
4475  startline = (re->options & PCRE_STARTLINE) != 0;  startline = (re->flags & PCRE_STARTLINE) != 0;
4476  firstline = (re->options & PCRE_FIRSTLINE) != 0;  firstline = (re->options & PCRE_FIRSTLINE) != 0;
4477    
4478  /* 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 4487  end_subject = md->end_subject;
4487    
4488  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;  md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
4489  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;  utf8 = md->utf8 = (re->options & PCRE_UTF8) != 0;
4490    md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
4491    
4492  md->notbol = (options & PCRE_NOTBOL) != 0;  md->notbol = (options & PCRE_NOTBOL) != 0;
4493  md->noteol = (options & PCRE_NOTEOL) != 0;  md->noteol = (options & PCRE_NOTEOL) != 0;
# Line 4396  md->recursive = NULL; Line 4500  md->recursive = NULL;
4500  md->lcc = tables + lcc_offset;  md->lcc = tables + lcc_offset;
4501  md->ctypes = tables + ctypes_offset;  md->ctypes = tables + ctypes_offset;
4502    
4503    /* Handle different \R options. */
4504    
4505    switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
4506      {
4507      case 0:
4508      if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
4509        md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
4510      else
4511    #ifdef BSR_ANYCRLF
4512      md->bsr_anycrlf = TRUE;
4513    #else
4514      md->bsr_anycrlf = FALSE;
4515    #endif
4516      break;
4517    
4518      case PCRE_BSR_ANYCRLF:
4519      md->bsr_anycrlf = TRUE;
4520      break;
4521    
4522      case PCRE_BSR_UNICODE:
4523      md->bsr_anycrlf = FALSE;
4524      break;
4525    
4526      default: return PCRE_ERROR_BADNEWLINE;
4527      }
4528    
4529  /* Handle different types of newline. The three bits give eight cases. If  /* Handle different types of newline. The three bits give eight cases. If
4530  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. */
4531    
4532  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &  switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
4533         PCRE_NEWLINE_BITS)          (pcre_uint32)options) & PCRE_NEWLINE_BITS)
4534    {    {
4535    case 0: newline = NEWLINE; break;   /* Compile-time default */    case 0: newline = NEWLINE; break;   /* Compile-time default */
4536    case PCRE_NEWLINE_CR: newline = '\r'; break;    case PCRE_NEWLINE_CR: newline = '\r'; break;
# Line 4439  else Line 4569  else
4569  /* 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
4570  moment. */  moment. */
4571    
4572  if (md->partial && (re->options & PCRE_NOPARTIAL) != 0)  if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
4573    return PCRE_ERROR_BADPARTIAL;    return PCRE_ERROR_BADPARTIAL;
4574    
4575  /* 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 4646  studied, there may be a bitmap of possib
4646    
4647  if (!anchored)  if (!anchored)
4648    {    {
4649    if ((re->options & PCRE_FIRSTSET) != 0)    if ((re->flags & PCRE_FIRSTSET) != 0)
4650      {      {
4651      first_byte = re->first_byte & 255;      first_byte = re->first_byte & 255;
4652      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 4661  if (!anchored)
4661  /* For anchored or unanchored matches, there may be a "last known required  /* For anchored or unanchored matches, there may be a "last known required
4662  character" set. */  character" set. */
4663    
4664  if ((re->options & PCRE_REQCHSET) != 0)  if ((re->flags & PCRE_REQCHSET) != 0)
4665    {    {
4666    req_byte = re->req_byte & 255;    req_byte = re->req_byte & 255;
4667    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 4677  the loop runs just once. */
4677  for(;;)  for(;;)
4678    {    {
4679    USPTR save_end_subject = end_subject;    USPTR save_end_subject = end_subject;
4680      USPTR new_start_match;
4681    
4682    /* Reset the maximum number of extractions we might see. */    /* Reset the maximum number of extractions we might see. */
4683    
# Line 4566  for(;;) Line 4697  for(;;)
4697    if (firstline)    if (firstline)
4698      {      {
4699      USPTR t = start_match;      USPTR t = start_match;
4700    #ifdef SUPPORT_UTF8
4701        if (utf8)
4702          {
4703          while (t < md->end_subject && !IS_NEWLINE(t))
4704            {
4705            t++;
4706            while (t < end_subject && (*t & 0xc0) == 0x80) t++;
4707            }
4708          }
4709        else
4710    #endif
4711      while (t < md->end_subject && !IS_NEWLINE(t)) t++;      while (t < md->end_subject && !IS_NEWLINE(t)) t++;
4712      end_subject = t;      end_subject = t;
4713      }      }
4714    
4715    /* Now test for a unique first byte */    /* Now advance to a unique first byte if there is one. */
4716    
4717    if (first_byte >= 0)    if (first_byte >= 0)
4718      {      {
4719      if (first_byte_caseless)      if (first_byte_caseless)
4720        while (start_match < end_subject &&        while (start_match < end_subject && md->lcc[*start_match] != first_byte)
              md->lcc[*start_match] != first_byte)  
4721          start_match++;          start_match++;
4722      else      else
4723        while (start_match < end_subject && *start_match != first_byte)        while (start_match < end_subject && *start_match != first_byte)
4724          start_match++;          start_match++;
4725      }      }
4726    
4727    /* Or to just after a linebreak for a multiline match if possible */    /* Or to just after a linebreak for a multiline match */
4728    
4729    else if (startline)    else if (startline)
4730      {      {
4731      if (start_match > md->start_subject + start_offset)      if (start_match > md->start_subject + start_offset)
4732        {        {
4733        while (start_match <= end_subject && !WAS_NEWLINE(start_match))  #ifdef SUPPORT_UTF8
4734          if (utf8)
4735            {
4736            while (start_match < end_subject && !WAS_NEWLINE(start_match))
4737              {
4738              start_match++;
4739              while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
4740                start_match++;
4741              }
4742            }
4743          else
4744    #endif
4745          while (start_match < end_subject && !WAS_NEWLINE(start_match))
4746          start_match++;          start_match++;
4747    
4748        /* 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,
4749        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.
4750        */        */
# Line 4604  for(;;) Line 4757  for(;;)
4757        }        }
4758      }      }
4759    
4760    /* Or to a non-unique first char after study */    /* Or to a non-unique first byte after study */
4761    
4762    else if (start_bits != NULL)    else if (start_bits != NULL)
4763      {      {
4764      while (start_match < end_subject)      while (start_match < end_subject)
4765        {        {
4766        register unsigned int c = *start_match;        register unsigned int c = *start_match;
4767        if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break;        if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++;
4768            else break;
4769        }        }
4770      }      }
4771    
# Line 4686  for(;;) Line 4840  for(;;)
4840      }      }
4841    
4842    /* OK, we can now run the match. */    /* OK, we can now run the match. */
4843    
4844    md->start_match_ptr = start_match;      /* Insurance */    md->start_match_ptr = start_match;
4845    md->match_call_count = 0;    md->match_call_count = 0;
4846    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);
4847    
4848    /* Any return other than MATCH_NOMATCH breaks the loop. */    switch(rc)
4849        {
4850        /* NOMATCH and PRUNE advance by one character. THEN at this level acts
4851        exactly like PRUNE. */
4852    
4853        case MATCH_NOMATCH:
4854        case MATCH_PRUNE:
4855        case MATCH_THEN:
4856        new_start_match = start_match + 1;
4857    #ifdef SUPPORT_UTF8
4858        if (utf8)
4859          while(new_start_match < end_subject && (*new_start_match & 0xc0) == 0x80)
4860            new_start_match++;
4861    #endif
4862        break;
4863    
4864        /* SKIP passes back the next starting point explicitly. */
4865    
4866        case MATCH_SKIP:
4867        new_start_match = md->start_match_ptr;
4868        break;
4869    
4870        /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
4871    
4872    if (rc != MATCH_NOMATCH) break;      case MATCH_COMMIT:
4873        rc = MATCH_NOMATCH;
4874        goto ENDLOOP;
4875    
4876        /* Any other return is some kind of error. */
4877    
4878        default:
4879        goto ENDLOOP;
4880        }
4881    
4882      /* Control reaches here for the various types of "no match at this point"
4883      result. Reset the code to MATCH_NOMATCH for subsequent checking. */
4884    
4885      rc = MATCH_NOMATCH;
4886    
4887    /* 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
4888    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 4890  for(;;)
4890    
4891    if (firstline && IS_NEWLINE(start_match)) break;    if (firstline && IS_NEWLINE(start_match)) break;
4892    
4893    /* Advance the match position by one character. */    /* Advance to new matching position */
4894    
4895    start_match++;    start_match = new_start_match;
 #ifdef SUPPORT_UTF8  
   if (utf8)  
     while(start_match < end_subject && (*start_match & 0xc0) == 0x80)  
       start_match++;  
 #endif  
4896    
4897    /* 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
4898    the subject. */    the subject. */
4899    
4900    if (anchored || start_match > end_subject) break;    if (anchored || start_match > end_subject) break;
4901    
4902    /* 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
4903    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
4904    character. */    or ANY or ANYCRLF, advance the match position by one more character. */
4905    
4906    if (start_match[-1] == '\r' &&    if (start_match[-1] == '\r' &&
4907         (md->nltype == NLTYPE_ANY ||        start_match < end_subject &&
4908          md->nltype == NLTYPE_ANYCRLF ||        *start_match == '\n' &&
4909          md->nllen == 2) &&        (re->flags & PCRE_HASCRORLF) == 0 &&
4910         start_match < end_subject &&          (md->nltype == NLTYPE_ANY ||
4911         *start_match == '\n')           md->nltype == NLTYPE_ANYCRLF ||
4912             md->nllen == 2))
4913      start_match++;      start_match++;
4914    
4915    }   /* End of for(;;) "bumpalong" loop */    }   /* End of for(;;) "bumpalong" loop */
# Line 4734  for(;;) Line 4919  for(;;)
4919  /* 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
4920  conditions is true:  conditions is true:
4921    
4922  (1) The pattern is anchored;  (1) The pattern is anchored or the match was failed by (*COMMIT);
4923    
4924  (2) We are past the end of the subject;  (2) We are past the end of the subject;
4925    
# Line 4749  processing, copy those that we can. In t Line 4934  processing, copy those that we can. In t
4934  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
4935  capturing parentheses than vector slots. */  capturing parentheses than vector slots. */
4936    
4937    ENDLOOP:
4938    
4939  if (rc == MATCH_MATCH)  if (rc == MATCH_MATCH)
4940    {    {
4941    if (using_temporary_offsets)    if (using_temporary_offsets)

Legend:
Removed from v.200  
changed lines
  Added in v.366

  ViewVC Help
Powered by ViewVC 1.1.5