/[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 893 by ph10, Thu Jan 19 17:15:11 2012 UTC revision 1046 by ph10, Tue Sep 25 16:27:58 2012 UTC
# Line 37  POSSIBILITY OF SUCH DAMAGE. Line 37  POSSIBILITY OF SUCH DAMAGE.
37  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
38  */  */
39    
   
40  /* This module contains pcre_exec(), the externally visible function that does  /* This module contains pcre_exec(), the externally visible function that does
41  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
42  possible. There are also some static supporting functions. */  possible. There are also some static supporting functions. */
# Line 140  Arguments: Line 139  Arguments:
139    md          points to match data block    md          points to match data block
140    caseless    TRUE if caseless    caseless    TRUE if caseless
141    
142  Returns:      < 0 if not matched, otherwise the number of subject bytes matched  Returns:      >= 0 the number of subject bytes matched
143                  -1 no match
144                  -2 partial match; always given if at end subject
145  */  */
146    
147  static int  static int
# Line 163  pchars(p, length, FALSE, md); Line 164  pchars(p, length, FALSE, md);
164  printf("\n");  printf("\n");
165  #endif  #endif
166    
167  /* Always fail if reference not set (and not JavaScript compatible). */  /* Always fail if reference not set (and not JavaScript compatible - in that
168    case the length is passed as zero). */
169    
170  if (length < 0) return -1;  if (length < 0) return -1;
171    
# Line 178  if (caseless) Line 180  if (caseless)
180    if (md->utf)    if (md->utf)
181      {      {
182      /* Match characters up to the end of the reference. NOTE: the number of      /* Match characters up to the end of the reference. NOTE: the number of
183      bytes matched may differ, because there are some characters whose upper and      data units matched may differ, because in UTF-8 there are some characters
184      lower case versions code as different numbers of bytes. For example, U+023A      whose upper and lower case versions code have different numbers of bytes.
185      (2 bytes in UTF-8) is the upper case version of U+2C65 (3 bytes in UTF-8);      For example, U+023A (2 bytes in UTF-8) is the upper case version of U+2C65
186      a sequence of 3 of the former uses 6 bytes, as does a sequence of two of      (3 bytes in UTF-8); a sequence of 3 of the former uses 6 bytes, as does a
187      the latter. It is important, therefore, to check the length along the      sequence of two of the latter. It is important, therefore, to check the
188      reference, not along the subject (earlier code did this wrong). */      length along the reference, not along the subject (earlier code did this
189        wrong). */
190    
191      PCRE_PUCHAR endptr = p + length;      PCRE_PUCHAR endptr = p + length;
192      while (p < endptr)      while (p < endptr)
193        {        {
194        int c, d;        unsigned int c, d;
195        if (eptr >= md->end_subject) return -1;        const ucd_record *ur;
196          if (eptr >= md->end_subject) return -2;   /* Partial match */
197        GETCHARINC(c, eptr);        GETCHARINC(c, eptr);
198        GETCHARINC(d, p);        GETCHARINC(d, p);
199        if (c != d && c != UCD_OTHERCASE(d)) return -1;        ur = GET_UCD(d);
200          if (c != d && c != d + ur->other_case)
201            {
202            const pcre_uint32 *pp = PRIV(ucd_caseless_sets) + ur->caseset;
203            for (;;)
204              {
205              if (c < *pp) return -1;
206              if (c == *pp++) break;
207              }
208            }
209        }        }
210      }      }
211    else    else
# Line 202  if (caseless) Line 215  if (caseless)
215    /* The same code works when not in UTF-8 mode and in UTF-8 mode when there    /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
216    is no UCP support. */    is no UCP support. */
217      {      {
     if (eptr + length > md->end_subject) return -1;  
218      while (length-- > 0)      while (length-- > 0)
219        {        {
220          if (eptr >= md->end_subject) return -2;   /* Partial match */
221        if (TABLE_GET(*p, md->lcc, *p) != TABLE_GET(*eptr, md->lcc, *eptr)) return -1;        if (TABLE_GET(*p, md->lcc, *p) != TABLE_GET(*eptr, md->lcc, *eptr)) return -1;
222        p++;        p++;
223        eptr++;        eptr++;
# Line 217  are in UTF-8 mode. */ Line 230  are in UTF-8 mode. */
230    
231  else  else
232    {    {
233    if (eptr + length > md->end_subject) return -1;    while (length-- > 0)
234    while (length-- > 0) if (*p++ != *eptr++) return -1;      {
235        if (eptr >= md->end_subject) return -2;   /* Partial match */
236        if (*p++ != *eptr++) return -1;
237        }
238    }    }
239    
240  return (int)(eptr - eptr_start);  return (int)(eptr - eptr_start);
# Line 311  argument of match(), which never changes Line 327  argument of match(), which never changes
327    
328  #define RMATCH(ra,rb,rc,rd,re,rw)\  #define RMATCH(ra,rb,rc,rd,re,rw)\
329    {\    {\
330    heapframe *newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\    heapframe *newframe = frame->Xnextframe;\
331    if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\    if (newframe == NULL)\
332    frame->Xwhere = rw; \      {\
333        newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
334        if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
335        newframe->Xnextframe = NULL;\
336        frame->Xnextframe = newframe;\
337        }\
338      frame->Xwhere = rw;\
339    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
340    newframe->Xecode = rb;\    newframe->Xecode = rb;\
341    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
# Line 332  argument of match(), which never changes Line 354  argument of match(), which never changes
354    {\    {\
355    heapframe *oldframe = frame;\    heapframe *oldframe = frame;\
356    frame = oldframe->Xprevframe;\    frame = oldframe->Xprevframe;\
   if (oldframe != &frame_zero) (PUBL(stack_free))(oldframe);\  
357    if (frame != NULL)\    if (frame != NULL)\
358      {\      {\
359      rrc = ra;\      rrc = ra;\
# Line 346  argument of match(), which never changes Line 367  argument of match(), which never changes
367    
368  typedef struct heapframe {  typedef struct heapframe {
369    struct heapframe *Xprevframe;    struct heapframe *Xprevframe;
370      struct heapframe *Xnextframe;
371    
372    /* Function arguments that may change */    /* Function arguments that may change */
373    
# Line 487  int condcode; Line 509  int condcode;
509  /* When recursion is not being used, all "local" variables that have to be  /* When recursion is not being used, all "local" variables that have to be
510  preserved over calls to RMATCH() are part of a "frame". We set up the top-level  preserved over calls to RMATCH() are part of a "frame". We set up the top-level
511  frame on the stack here; subsequent instantiations are obtained from the heap  frame on the stack here; subsequent instantiations are obtained from the heap
512  whenever RMATCH() does a "recursion". See the macro definitions above. Putting  whenever RMATCH() does a "recursion". See the macro definitions above. Putting
513  the top-level on the stack rather than malloc-ing them all gives a performance  the top-level on the stack rather than malloc-ing them all gives a performance
514  boost in many cases where there is not much "recursion". */  boost in many cases where there is not much "recursion". */
515    
516  #ifdef NO_RECURSE  #ifdef NO_RECURSE
517  heapframe frame_zero;  heapframe *frame = (heapframe *)md->match_frames_base;
 heapframe *frame = &frame_zero;  
 frame->Xprevframe = NULL;            /* Marks the top level */  
518    
519  /* Copy in the original argument variables */  /* Copy in the original argument variables */
520    
# Line 616  int stacksave[REC_STACK_SAVE_MAX]; Line 636  int stacksave[REC_STACK_SAVE_MAX];
636    
637  eptrblock newptrb;  eptrblock newptrb;
638    
639  /* There is a special fudge for calling match() in a way that causes it to  /* There is a special fudge for calling match() in a way that causes it to
640  measure the size of its basic stack frame when the stack is being used for  measure the size of its basic stack frame when the stack is being used for
641  recursion. The first argument (eptr) points to a pointer that is used  recursion. The second argument (ecode) being NULL triggers this behaviour. It
642  "statically" for doing the calculation. The second argument (ecode) being NULL  cannot normally ever be NULL. The return is the negated value of the frame
643  triggers this behaviour. It cannot normally every be NULL. The return is the  size. */
 negated value of the frame size. */  
644    
645  if (ecode == NULL)  if (ecode == NULL)
646    {    {
   char **aptr = (char **)eptr;  
647    if (rdepth == 0)    if (rdepth == 0)
648      {      return match((PCRE_PUCHAR)&rdepth, NULL, NULL, 0, NULL, NULL, 1);
     *aptr = (char *)&rdepth;  
     return match(eptr, NULL, NULL, 0, NULL, NULL, 1);  
     }  
649    else    else
650      {      {
651      int len = (char *)&rdepth - *aptr;      int len = (char *)&rdepth - (char *)eptr;
652      return (len > 0)? -len : len;      return (len > 0)? -len : len;
653      }      }
654    }    }
655  #endif     /* NO_RECURSE */  #endif     /* NO_RECURSE */
656    
657  /* To save space on the stack and in the heap frame, I have doubled up on some  /* To save space on the stack and in the heap frame, I have doubled up on some
# Line 843  for (;;) Line 858  for (;;)
858      case OP_ONCE_NC:      case OP_ONCE_NC:
859      prev = ecode;      prev = ecode;
860      saved_eptr = eptr;      saved_eptr = eptr;
861      save_mark = md->mark;      save_mark = md->mark;
862      do      do
863        {        {
864        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
# Line 862  for (;;) Line 877  for (;;)
877    
878        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
879        ecode += GET(ecode,1);        ecode += GET(ecode,1);
880        md->mark = save_mark;        md->mark = save_mark;
881        }        }
882      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
883    
# Line 902  for (;;) Line 917  for (;;)
917        }        }
918      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
919        {        {
       md->match_function_type = MATCH_CBEGROUP;  
920        RMATCH(eptr, prev, offset_top, md, eptrb, RM66);        RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
921        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
922        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
# Line 942  for (;;) Line 956  for (;;)
956        save_offset2 = md->offset_vector[offset+1];        save_offset2 = md->offset_vector[offset+1];
957        save_offset3 = md->offset_vector[md->offset_end - number];        save_offset3 = md->offset_vector[md->offset_end - number];
958        save_capture_last = md->capture_last;        save_capture_last = md->capture_last;
959        save_mark = md->mark;        save_mark = md->mark;
960    
961        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
962        md->offset_vector[md->offset_end - number] =        md->offset_vector[md->offset_end - number] =
# Line 1031  for (;;) Line 1045  for (;;)
1045    
1046      for (;;)      for (;;)
1047        {        {
1048        if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;        if (op >= OP_SBRA || op == OP_ONCE)
1049            md->match_function_type = MATCH_CBEGROUP;
1050    
1051        /* If this is not a possibly empty group, and there are no (*THEN)s in        /* If this is not a possibly empty group, and there are no (*THEN)s in
1052        the pattern, and this is the final alternative, optimize as described        the pattern, and this is the final alternative, optimize as described
# Line 1048  for (;;) Line 1063  for (;;)
1063        save_mark = md->mark;        save_mark = md->mark;
1064        RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,        RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,
1065          RM2);          RM2);
1066    
1067        /* See comment in the code for capturing groups above about handling        /* See comment in the code for capturing groups above about handling
1068        THEN. */        THEN. */
1069    
# Line 1075  for (;;) Line 1090  for (;;)
1090          RRETURN(rrc);          RRETURN(rrc);
1091          }          }
1092        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1093        md->mark = save_mark;        md->mark = save_mark;
1094        if (*ecode != OP_ALT) break;        if (*ecode != OP_ALT) break;
1095        }        }
1096    
# Line 1554  for (;;) Line 1569  for (;;)
1569    
1570      case OP_ASSERT:      case OP_ASSERT:
1571      case OP_ASSERTBACK:      case OP_ASSERTBACK:
1572      save_mark = md->mark;      save_mark = md->mark;
1573      if (md->match_function_type == MATCH_CONDASSERT)      if (md->match_function_type == MATCH_CONDASSERT)
1574        {        {
1575        condassert = TRUE;        condassert = TRUE;
# Line 1570  for (;;) Line 1585  for (;;)
1585          mstart = md->start_match_ptr;   /* In case \K reset it */          mstart = md->start_match_ptr;   /* In case \K reset it */
1586          break;          break;
1587          }          }
1588          md->mark = save_mark;
1589    
1590        /* PCRE does not allow THEN to escape beyond an assertion; it is treated        /* A COMMIT failure must fail the entire assertion, without trying any
1591        as NOMATCH. */        subsequent branches. */
1592    
1593          if (rrc == MATCH_COMMIT) RRETURN(MATCH_NOMATCH);
1594    
1595          /* PCRE does not allow THEN to escape beyond an assertion; it
1596          is treated as NOMATCH. */
1597    
1598        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1599        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
       md->mark = save_mark;  
1600        }        }
1601      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
1602    
# Line 1600  for (;;) Line 1620  for (;;)
1620    
1621      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1622      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
1623      save_mark = md->mark;      save_mark = md->mark;
1624      if (md->match_function_type == MATCH_CONDASSERT)      if (md->match_function_type == MATCH_CONDASSERT)
1625        {        {
1626        condassert = TRUE;        condassert = TRUE;
# Line 1611  for (;;) Line 1631  for (;;)
1631      do      do
1632        {        {
1633        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
1634        md->mark = save_mark;        md->mark = save_mark;
1635        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);
1636        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1637          {          {
# Line 1784  for (;;) Line 1804  for (;;)
1804            goto RECURSION_MATCHED;        /* Exit loop; end processing */            goto RECURSION_MATCHED;        /* Exit loop; end processing */
1805            }            }
1806    
1807          /* PCRE does not allow THEN to escape beyond a recursion; it is treated          /* PCRE does not allow THEN or COMMIT to escape beyond a recursion; it
1808          as NOMATCH. */          is treated as NOMATCH. */
1809    
1810          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN &&
1811                     rrc != MATCH_COMMIT)
1812            {            {
1813            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1814            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
# Line 1998  for (;;) Line 2019  for (;;)
2019          }          }
2020        if (*prev >= OP_SBRA)    /* Could match an empty string */        if (*prev >= OP_SBRA)    /* Could match an empty string */
2021          {          {
         md->match_function_type = MATCH_CBEGROUP;  
2022          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
2023          RRETURN(rrc);          RRETURN(rrc);
2024          }          }
# Line 2007  for (;;) Line 2027  for (;;)
2027        }        }
2028      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
2029        {        {
       if (*prev >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;  
2030        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
2031        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
2032        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
# Line 2064  for (;;) Line 2083  for (;;)
2083    
2084      case OP_DOLLM:      case OP_DOLLM:
2085      if (eptr < md->end_subject)      if (eptr < md->end_subject)
2086        { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }        {
2087          if (!IS_NEWLINE(eptr))
2088            {
2089            if (md->partial != 0 &&
2090                eptr + 1 >= md->end_subject &&
2091                NLBLOCK->nltype == NLTYPE_FIXED &&
2092                NLBLOCK->nllen == 2 &&
2093                *eptr == NLBLOCK->nl[0])
2094              {
2095              md->hitend = TRUE;
2096              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2097              }
2098            RRETURN(MATCH_NOMATCH);
2099            }
2100          }
2101      else      else
2102        {        {
2103        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) RRETURN(MATCH_NOMATCH);
# Line 2096  for (;;) Line 2129  for (;;)
2129      ASSERT_NL_OR_EOS:      ASSERT_NL_OR_EOS:
2130      if (eptr < md->end_subject &&      if (eptr < md->end_subject &&
2131          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
2132          {
2133          if (md->partial != 0 &&
2134              eptr + 1 >= md->end_subject &&
2135              NLBLOCK->nltype == NLTYPE_FIXED &&
2136              NLBLOCK->nllen == 2 &&
2137              *eptr == NLBLOCK->nl[0])
2138            {
2139            md->hitend = TRUE;
2140            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2141            }
2142        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2143          }
2144    
2145      /* Either at end of string or \n before end. */      /* Either at end of string or \n before end. */
2146    
# Line 2224  for (;;) Line 2268  for (;;)
2268        }        }
2269      break;      break;
2270    
2271      /* Match a single character type; inline for speed */      /* Match any single character type except newline; have to take care with
2272        CRLF newlines and partial matching. */
2273    
2274      case OP_ANY:      case OP_ANY:
2275      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
2276        if (md->partial != 0 &&
2277            eptr + 1 >= md->end_subject &&
2278            NLBLOCK->nltype == NLTYPE_FIXED &&
2279            NLBLOCK->nllen == 2 &&
2280            *eptr == NLBLOCK->nl[0])
2281          {
2282          md->hitend = TRUE;
2283          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2284          }
2285    
2286      /* Fall through */      /* Fall through */
2287    
2288        /* Match any single character whatsoever. */
2289    
2290      case OP_ALLANY:      case OP_ALLANY:
2291      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */      if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
2292        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
# Line 2369  for (;;) Line 2426  for (;;)
2426        {        {
2427        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2428    
2429        case 0x000d:        case CHAR_CR:
2430        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr >= md->end_subject)
2431            {
2432            SCHECK_PARTIAL();
2433            }
2434          else if (*eptr == CHAR_LF) eptr++;
2435        break;        break;
2436    
2437        case 0x000a:        case CHAR_LF:
2438        break;        break;
2439    
2440        case 0x000b:        case CHAR_VT:
2441        case 0x000c:        case CHAR_FF:
2442        case 0x0085:        case CHAR_NEL:
2443    #ifndef EBCDIC
2444        case 0x2028:        case 0x2028:
2445        case 0x2029:        case 0x2029:
2446    #endif  /* Not EBCDIC */
2447        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2448        break;        break;
2449        }        }
# Line 2396  for (;;) Line 2459  for (;;)
2459      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2460      switch(c)      switch(c)
2461        {        {
2462          HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
2463        default: break;        default: break;
       case 0x09:      /* HT */  
       case 0x20:      /* SPACE */  
       case 0xa0:      /* NBSP */  
       case 0x1680:    /* OGHAM SPACE MARK */  
       case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
       case 0x2000:    /* EN QUAD */  
       case 0x2001:    /* EM QUAD */  
       case 0x2002:    /* EN SPACE */  
       case 0x2003:    /* EM SPACE */  
       case 0x2004:    /* THREE-PER-EM SPACE */  
       case 0x2005:    /* FOUR-PER-EM SPACE */  
       case 0x2006:    /* SIX-PER-EM SPACE */  
       case 0x2007:    /* FIGURE SPACE */  
       case 0x2008:    /* PUNCTUATION SPACE */  
       case 0x2009:    /* THIN SPACE */  
       case 0x200A:    /* HAIR SPACE */  
       case 0x202f:    /* NARROW NO-BREAK SPACE */  
       case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
       case 0x3000:    /* IDEOGRAPHIC SPACE */  
       RRETURN(MATCH_NOMATCH);  
2464        }        }
2465      ecode++;      ecode++;
2466      break;      break;
# Line 2430  for (;;) Line 2474  for (;;)
2474      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2475      switch(c)      switch(c)
2476        {        {
2477          HSPACE_CASES: break;  /* Byte and multibyte cases */
2478        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
       case 0x09:      /* HT */  
       case 0x20:      /* SPACE */  
       case 0xa0:      /* NBSP */  
       case 0x1680:    /* OGHAM SPACE MARK */  
       case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
       case 0x2000:    /* EN QUAD */  
       case 0x2001:    /* EM QUAD */  
       case 0x2002:    /* EN SPACE */  
       case 0x2003:    /* EM SPACE */  
       case 0x2004:    /* THREE-PER-EM SPACE */  
       case 0x2005:    /* FOUR-PER-EM SPACE */  
       case 0x2006:    /* SIX-PER-EM SPACE */  
       case 0x2007:    /* FIGURE SPACE */  
       case 0x2008:    /* PUNCTUATION SPACE */  
       case 0x2009:    /* THIN SPACE */  
       case 0x200A:    /* HAIR SPACE */  
       case 0x202f:    /* NARROW NO-BREAK SPACE */  
       case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
       case 0x3000:    /* IDEOGRAPHIC SPACE */  
       break;  
2479        }        }
2480      ecode++;      ecode++;
2481      break;      break;
# Line 2464  for (;;) Line 2489  for (;;)
2489      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2490      switch(c)      switch(c)
2491        {        {
2492          VSPACE_CASES: RRETURN(MATCH_NOMATCH);
2493        default: break;        default: break;
       case 0x0a:      /* LF */  
       case 0x0b:      /* VT */  
       case 0x0c:      /* FF */  
       case 0x0d:      /* CR */  
       case 0x85:      /* NEL */  
       case 0x2028:    /* LINE SEPARATOR */  
       case 0x2029:    /* PARAGRAPH SEPARATOR */  
       RRETURN(MATCH_NOMATCH);  
2494        }        }
2495      ecode++;      ecode++;
2496      break;      break;
# Line 2486  for (;;) Line 2504  for (;;)
2504      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2505      switch(c)      switch(c)
2506        {        {
2507          VSPACE_CASES: break;
2508        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
       case 0x0a:      /* LF */  
       case 0x0b:      /* VT */  
       case 0x0c:      /* FF */  
       case 0x0d:      /* CR */  
       case 0x85:      /* NEL */  
       case 0x2028:    /* LINE SEPARATOR */  
       case 0x2029:    /* PARAGRAPH SEPARATOR */  
       break;  
2509        }        }
2510      ecode++;      ecode++;
2511      break;      break;
# Line 2512  for (;;) Line 2523  for (;;)
2523        }        }
2524      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2525        {        {
2526          const pcre_uint32 *cp;
2527        const ucd_record *prop = GET_UCD(c);        const ucd_record *prop = GET_UCD(c);
2528    
2529        switch(ecode[1])        switch(ecode[1])
# Line 2571  for (;;) Line 2583  for (;;)
2583               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))               c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
2584            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2585          break;          break;
2586    
2587            case PT_CLIST:
2588            cp = PRIV(ucd_caseless_sets) + prop->caseset;
2589            for (;;)
2590              {
2591              if (c < *cp)
2592                { if (op == OP_PROP) RRETURN(MATCH_NOMATCH); else break; }
2593              if (c == *cp++)
2594                { if (op == OP_PROP) break; else RRETURN(MATCH_NOMATCH); }
2595              }
2596            break;
2597    
2598          /* This should never occur */          /* This should never occur */
2599    
# Line 2591  for (;;) Line 2614  for (;;)
2614        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2615        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2616        }        }
2617      GETCHARINCTEST(c, eptr);      else
     if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
     while (eptr < md->end_subject)  
2618        {        {
2619        int len = 1;        int lgb, rgb;
2620        if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }        GETCHARINCTEST(c, eptr);
2621        if (UCD_CATEGORY(c) != ucp_M) break;        lgb = UCD_GRAPHBREAK(c);
2622        eptr += len;        while (eptr < md->end_subject)
2623            {
2624            int len = 1;
2625            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2626            rgb = UCD_GRAPHBREAK(c);
2627            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2628            lgb = rgb;
2629            eptr += len;
2630            }
2631        }        }
2632        CHECK_PARTIAL();
2633      ecode++;      ecode++;
2634      break;      break;
2635  #endif  #endif  /* SUPPORT_UCP */
2636    
2637    
2638      /* Match a back reference, possibly repeatedly. Look past the end of the      /* Match a back reference, possibly repeatedly. Look past the end of the
# Line 2665  for (;;) Line 2695  for (;;)
2695        default:               /* No repeat follows */        default:               /* No repeat follows */
2696        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2697          {          {
2698            if (length == -2) eptr = md->end_subject;   /* Partial match */
2699          CHECK_PARTIAL();          CHECK_PARTIAL();
2700          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2701          }          }
# Line 2690  for (;;) Line 2721  for (;;)
2721        int slength;        int slength;
2722        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2723          {          {
2724            if (slength == -2) eptr = md->end_subject;   /* Partial match */
2725          CHECK_PARTIAL();          CHECK_PARTIAL();
2726          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2727          }          }
# Line 2713  for (;;) Line 2745  for (;;)
2745          if (fi >= max) RRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2746          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2747            {            {
2748              if (slength == -2) eptr = md->end_subject;   /* Partial match */
2749            CHECK_PARTIAL();            CHECK_PARTIAL();
2750            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2751            }            }
# Line 2731  for (;;) Line 2764  for (;;)
2764          int slength;          int slength;
2765          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2766            {            {
2767            CHECK_PARTIAL();            /* Can't use CHECK_PARTIAL because we don't want to update eptr in
2768              the soft partial matching case. */
2769    
2770              if (slength == -2 && md->partial != 0 &&
2771                  md->end_subject > md->start_used_ptr)
2772                {
2773                md->hitend = TRUE;
2774                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2775                }
2776            break;            break;
2777            }            }
2778          eptr += slength;          eptr += slength;
2779          }          }
2780    
2781        while (eptr >= pp)        while (eptr >= pp)
2782          {          {
2783          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
# Line 3365  for (;;) Line 3407  for (;;)
3407      maximizing, find the maximum number of characters and work backwards. */      maximizing, find the maximum number of characters and work backwards. */
3408    
3409      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3410        max, eptr));        max, (char *)eptr));
3411    
3412      if (op >= OP_STARI)  /* Caseless */      if (op >= OP_STARI)  /* Caseless */
3413        {        {
# Line 3509  for (;;) Line 3551  for (;;)
3551        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3552        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3553        }        }
     ecode++;  
     GETCHARINCTEST(c, eptr);  
     if (op == OP_NOTI)         /* The caseless case */  
       {  
       register int ch, och;  
       ch = *ecode++;  
 #ifdef COMPILE_PCRE8  
       /* ch must be < 128 if UTF is enabled. */  
       och = md->fcc[ch];  
 #else  
3554  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3555        if (utf)
3556          {
3557          register unsigned int ch, och;
3558    
3559          ecode++;
3560          GETCHARINC(ch, ecode);
3561          GETCHARINC(c, eptr);
3562    
3563          if (op == OP_NOT)
3564            {
3565            if (ch == c) RRETURN(MATCH_NOMATCH);
3566            }
3567          else
3568            {
3569  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3570        if (utf && ch > 127)          if (ch > 127)
3571          och = UCD_OTHERCASE(ch);            och = UCD_OTHERCASE(ch);
3572  #else  #else
3573        if (utf && ch > 127)          if (ch > 127)
3574          och = ch;            och = ch;
3575  #endif /* SUPPORT_UCP */  #endif /* SUPPORT_UCP */
3576        else          else
3577  #endif /* SUPPORT_UTF */            och = TABLE_GET(ch, md->fcc, ch);
3578          och = TABLE_GET(ch, md->fcc, ch);          if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
3579  #endif /* COMPILE_PCRE8 */          }
       if (ch == c || och == c) RRETURN(MATCH_NOMATCH);  
3580        }        }
3581      else    /* Caseful */      else
3582    #endif
3583        {        {
3584        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        register unsigned int ch = ecode[1];
3585          c = *eptr++;
3586          if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3587            RRETURN(MATCH_NOMATCH);
3588          ecode += 2;
3589        }        }
3590      break;      break;
3591    
# Line 3615  for (;;) Line 3665  for (;;)
3665      /* Common code for all repeated single-byte matches. */      /* Common code for all repeated single-byte matches. */
3666    
3667      REPEATNOTCHAR:      REPEATNOTCHAR:
3668      fc = *ecode++;      GETCHARINCTEST(fc, ecode);
3669    
3670      /* The code is duplicated for the caseless and caseful cases, for speed,      /* The code is duplicated for the caseless and caseful cases, for speed,
3671      since matching characters is likely to be quite common. First, ensure the      since matching characters is likely to be quite common. First, ensure the
# Line 3626  for (;;) Line 3676  for (;;)
3676      characters and work backwards. */      characters and work backwards. */
3677    
3678      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3679        max, eptr));        max, (char *)eptr));
3680    
3681      if (op >= OP_NOTSTARI)     /* Caseless */      if (op >= OP_NOTSTARI)     /* Caseless */
3682        {        {
 #ifdef COMPILE_PCRE8  
       /* fc must be < 128 if UTF is enabled. */  
       foc = md->fcc[fc];  
 #else  
3683  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3684  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3685        if (utf && fc > 127)        if (utf && fc > 127)
# Line 3645  for (;;) Line 3691  for (;;)
3691        else        else
3692  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
3693          foc = TABLE_GET(fc, md->fcc, fc);          foc = TABLE_GET(fc, md->fcc, fc);
 #endif /* COMPILE_PCRE8 */  
3694    
3695  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3696        if (utf)        if (utf)
# Line 3659  for (;;) Line 3704  for (;;)
3704              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3705              }              }
3706            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3707            if (fc == d || foc == d) RRETURN(MATCH_NOMATCH);            if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3708            }            }
3709          }          }
3710        else        else
# Line 3697  for (;;) Line 3742  for (;;)
3742                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3743                }                }
3744              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3745              if (fc == d || foc == d) RRETURN(MATCH_NOMATCH);              if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3746              }              }
3747            }            }
3748          else          else
# Line 3740  for (;;) Line 3785  for (;;)
3785                break;                break;
3786                }                }
3787              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3788              if (fc == d || foc == d) break;              if (fc == d || (unsigned int)foc == d) break;
3789              eptr += len;              eptr += len;
3790              }              }
3791            if (possessive) continue;            if (possessive) continue;
# Line 4140  for (;;) Line 4185  for (;;)
4185                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
4186              }              }
4187            break;            break;
4188    
4189              case PT_CLIST:
4190              for (i = 1; i <= min; i++)
4191                {
4192                const pcre_uint32 *cp;
4193                if (eptr >= md->end_subject)
4194                  {
4195                  SCHECK_PARTIAL();
4196                  RRETURN(MATCH_NOMATCH);
4197                  }
4198                GETCHARINCTEST(c, eptr);
4199                cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);
4200                for (;;)
4201                  {
4202                  if (c < *cp)
4203                    { if (prop_fail_result) break; else RRETURN(MATCH_NOMATCH); }
4204                  if (c == *cp++)
4205                    { if (prop_fail_result) RRETURN(MATCH_NOMATCH); else break; }
4206                  }
4207                }
4208              break;
4209    
4210            /* This should not occur */            /* This should not occur */
4211    
4212            default:            default:
# Line 4160  for (;;) Line 4226  for (;;)
4226              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4227              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4228              }              }
4229            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4230              {              {
4231              int len = 1;              int lgb, rgb;
4232              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4233              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4234              eptr += len;             while (eptr < md->end_subject)
4235                  {
4236                  int len = 1;
4237                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4238                  rgb = UCD_GRAPHBREAK(c);
4239                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4240                  lgb = rgb;
4241                  eptr += len;
4242                  }
4243              }              }
4244              CHECK_PARTIAL();
4245            }            }
4246          }          }
4247    
# Line 4189  for (;;) Line 4262  for (;;)
4262              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4263              }              }
4264            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4265              if (md->partial != 0 &&
4266                  eptr + 1 >= md->end_subject &&
4267                  NLBLOCK->nltype == NLTYPE_FIXED &&
4268                  NLBLOCK->nllen == 2 &&
4269                  *eptr == NLBLOCK->nl[0])
4270                {
4271                md->hitend = TRUE;
4272                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4273                }
4274            eptr++;            eptr++;
4275            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4276            }            }
# Line 4225  for (;;) Line 4307  for (;;)
4307              {              {
4308              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4309    
4310              case 0x000d:              case CHAR_CR:
4311              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4312              break;              break;
4313    
4314              case 0x000a:              case CHAR_LF:
4315              break;              break;
4316    
4317              case 0x000b:              case CHAR_VT:
4318              case 0x000c:              case CHAR_FF:
4319              case 0x0085:              case CHAR_NEL:
4320    #ifndef EBCDIC
4321              case 0x2028:              case 0x2028:
4322              case 0x2029:              case 0x2029:
4323    #endif  /* Not EBCDIC */
4324              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4325              break;              break;
4326              }              }
# Line 4254  for (;;) Line 4338  for (;;)
4338            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4339            switch(c)            switch(c)
4340              {              {
4341                HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
4342              default: break;              default: break;
             case 0x09:      /* HT */  
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
             case 0x1680:    /* OGHAM SPACE MARK */  
             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
             case 0x2000:    /* EN QUAD */  
             case 0x2001:    /* EM QUAD */  
             case 0x2002:    /* EN SPACE */  
             case 0x2003:    /* EM SPACE */  
             case 0x2004:    /* THREE-PER-EM SPACE */  
             case 0x2005:    /* FOUR-PER-EM SPACE */  
             case 0x2006:    /* SIX-PER-EM SPACE */  
             case 0x2007:    /* FIGURE SPACE */  
             case 0x2008:    /* PUNCTUATION SPACE */  
             case 0x2009:    /* THIN SPACE */  
             case 0x200A:    /* HAIR SPACE */  
             case 0x202f:    /* NARROW NO-BREAK SPACE */  
             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
             case 0x3000:    /* IDEOGRAPHIC SPACE */  
             RRETURN(MATCH_NOMATCH);  
4343              }              }
4344            }            }
4345          break;          break;
# Line 4290  for (;;) Line 4355  for (;;)
4355            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4356            switch(c)            switch(c)
4357              {              {
4358                HSPACE_CASES: break;  /* Byte and multibyte cases */
4359              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
             case 0x09:      /* HT */  
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
             case 0x1680:    /* OGHAM SPACE MARK */  
             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
             case 0x2000:    /* EN QUAD */  
             case 0x2001:    /* EM QUAD */  
             case 0x2002:    /* EN SPACE */  
             case 0x2003:    /* EM SPACE */  
             case 0x2004:    /* THREE-PER-EM SPACE */  
             case 0x2005:    /* FOUR-PER-EM SPACE */  
             case 0x2006:    /* SIX-PER-EM SPACE */  
             case 0x2007:    /* FIGURE SPACE */  
             case 0x2008:    /* PUNCTUATION SPACE */  
             case 0x2009:    /* THIN SPACE */  
             case 0x200A:    /* HAIR SPACE */  
             case 0x202f:    /* NARROW NO-BREAK SPACE */  
             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
             case 0x3000:    /* IDEOGRAPHIC SPACE */  
             break;  
4360              }              }
4361            }            }
4362          break;          break;
# Line 4326  for (;;) Line 4372  for (;;)
4372            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4373            switch(c)            switch(c)
4374              {              {
4375                VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4376              default: break;              default: break;
             case 0x0a:      /* LF */  
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
             case 0x2028:    /* LINE SEPARATOR */  
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
             RRETURN(MATCH_NOMATCH);  
4377              }              }
4378            }            }
4379          break;          break;
# Line 4350  for (;;) Line 4389  for (;;)
4389            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4390            switch(c)            switch(c)
4391              {              {
4392                VSPACE_CASES: break;
4393              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
             case 0x0a:      /* LF */  
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
             case 0x2028:    /* LINE SEPARATOR */  
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
             break;  
4394              }              }
4395            }            }
4396          break;          break;
# Line 4473  for (;;) Line 4505  for (;;)
4505              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4506              }              }
4507            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4508              if (md->partial != 0 &&
4509                  eptr + 1 >= md->end_subject &&
4510                  NLBLOCK->nltype == NLTYPE_FIXED &&
4511                  NLBLOCK->nllen == 2 &&
4512                  *eptr == NLBLOCK->nl[0])
4513                {
4514                md->hitend = TRUE;
4515                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4516                }
4517            eptr++;            eptr++;
4518            }            }
4519          break;          break;
# Line 4507  for (;;) Line 4548  for (;;)
4548              {              {
4549              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4550    
4551              case 0x000d:              case CHAR_CR:
4552              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4553              break;              break;
4554    
4555              case 0x000a:              case CHAR_LF:
4556              break;              break;
4557    
4558              case 0x000b:              case CHAR_VT:
4559              case 0x000c:              case CHAR_FF:
4560              case 0x0085:              case CHAR_NEL:
4561  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4562              case 0x2028:              case 0x2028:
4563              case 0x2029:              case 0x2029:
# Line 4538  for (;;) Line 4579  for (;;)
4579            switch(*eptr++)            switch(*eptr++)
4580              {              {
4581              default: break;              default: break;
4582              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
4583  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4584              case 0x1680:    /* OGHAM SPACE MARK */              HSPACE_MULTIBYTE_CASES:
             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
             case 0x2000:    /* EN QUAD */  
             case 0x2001:    /* EM QUAD */  
             case 0x2002:    /* EN SPACE */  
             case 0x2003:    /* EM SPACE */  
             case 0x2004:    /* THREE-PER-EM SPACE */  
             case 0x2005:    /* FOUR-PER-EM SPACE */  
             case 0x2006:    /* SIX-PER-EM SPACE */  
             case 0x2007:    /* FIGURE SPACE */  
             case 0x2008:    /* PUNCTUATION SPACE */  
             case 0x2009:    /* THIN SPACE */  
             case 0x200A:    /* HAIR SPACE */  
             case 0x202f:    /* NARROW NO-BREAK SPACE */  
             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
             case 0x3000:    /* IDEOGRAPHIC SPACE */  
4585  #endif  #endif
4586              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4587              }              }
# Line 4575  for (;;) Line 4599  for (;;)
4599            switch(*eptr++)            switch(*eptr++)
4600              {              {
4601              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4602              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
4603  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4604              case 0x1680:    /* OGHAM SPACE MARK */              HSPACE_MULTIBYTE_CASES:
             case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
             case 0x2000:    /* EN QUAD */  
             case 0x2001:    /* EM QUAD */  
             case 0x2002:    /* EN SPACE */  
             case 0x2003:    /* EM SPACE */  
             case 0x2004:    /* THREE-PER-EM SPACE */  
             case 0x2005:    /* FOUR-PER-EM SPACE */  
             case 0x2006:    /* SIX-PER-EM SPACE */  
             case 0x2007:    /* FIGURE SPACE */  
             case 0x2008:    /* PUNCTUATION SPACE */  
             case 0x2009:    /* THIN SPACE */  
             case 0x200A:    /* HAIR SPACE */  
             case 0x202f:    /* NARROW NO-BREAK SPACE */  
             case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
             case 0x3000:    /* IDEOGRAPHIC SPACE */  
4605  #endif  #endif
4606              break;              break;
4607              }              }
# Line 4611  for (;;) Line 4618  for (;;)
4618              }              }
4619            switch(*eptr++)            switch(*eptr++)
4620              {              {
4621              default: break;              VSPACE_BYTE_CASES:
             case 0x0a:      /* LF */  
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
4622  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4623              case 0x2028:    /* LINE SEPARATOR */              VSPACE_MULTIBYTE_CASES:
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4624  #endif  #endif
4625              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4626                default: break;
4627              }              }
4628            }            }
4629          break;          break;
# Line 4637  for (;;) Line 4639  for (;;)
4639            switch(*eptr++)            switch(*eptr++)
4640              {              {
4641              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4642              case 0x0a:      /* LF */              VSPACE_BYTE_CASES:
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
4643  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4644              case 0x2028:    /* LINE SEPARATOR */              VSPACE_MULTIBYTE_CASES:
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4645  #endif  #endif
4646              break;              break;
4647              }              }
# Line 4922  for (;;) Line 4919  for (;;)
4919              }              }
4920            /* Control never gets here */            /* Control never gets here */
4921    
4922            /* This should never occur */            case PT_CLIST:
4923              for (fi = min;; fi++)
4924                {
4925                const pcre_uint32 *cp;
4926                RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);
4927                if (rrc != MATCH_NOMATCH) RRETURN(rrc);
4928                if (fi >= max) RRETURN(MATCH_NOMATCH);
4929                if (eptr >= md->end_subject)
4930                  {
4931                  SCHECK_PARTIAL();
4932                  RRETURN(MATCH_NOMATCH);
4933                  }
4934                GETCHARINCTEST(c, eptr);
4935                cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);
4936                for (;;)
4937                  {
4938                  if (c < *cp)
4939                    { if (prop_fail_result) break; else RRETURN(MATCH_NOMATCH); }
4940                  if (c == *cp++)
4941                    { if (prop_fail_result) RRETURN(MATCH_NOMATCH); else break; }
4942                  }
4943                }
4944              /* Control never gets here */
4945    
4946              /* This should never occur */
4947            default:            default:
4948            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
4949            }            }
# Line 4944  for (;;) Line 4964  for (;;)
4964              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4965              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4966              }              }
4967            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4968              {              {
4969              int len = 1;              int lgb, rgb;
4970              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4971              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4972              eptr += len;              while (eptr < md->end_subject)
4973                  {
4974                  int len = 1;
4975                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4976                  rgb = UCD_GRAPHBREAK(c);
4977                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4978                  lgb = rgb;
4979                  eptr += len;
4980                  }
4981              }              }
4982              CHECK_PARTIAL();
4983            }            }
4984          }          }
4985        else        else
# Line 4976  for (;;) Line 5003  for (;;)
5003            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
5004            switch(ctype)            switch(ctype)
5005              {              {
5006              case OP_ANY:        /* This is the non-NL case */              case OP_ANY:               /* This is the non-NL case */
5007                if (md->partial != 0 &&    /* Take care with CRLF partial */
5008                    eptr >= md->end_subject &&
5009                    NLBLOCK->nltype == NLTYPE_FIXED &&
5010                    NLBLOCK->nllen == 2 &&
5011                    c == NLBLOCK->nl[0])
5012                  {
5013                  md->hitend = TRUE;
5014                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5015                  }
5016                break;
5017    
5018              case OP_ALLANY:              case OP_ALLANY:
5019              case OP_ANYBYTE:              case OP_ANYBYTE:
5020              break;              break;
# Line 4985  for (;;) Line 5023  for (;;)
5023              switch(c)              switch(c)
5024                {                {
5025                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5026                case 0x000d:                case CHAR_CR:
5027                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5028                break;                break;
5029                case 0x000a:  
5030                  case CHAR_LF:
5031                break;                break;
5032    
5033                case 0x000b:                case CHAR_VT:
5034                case 0x000c:                case CHAR_FF:
5035                case 0x0085:                case CHAR_NEL:
5036    #ifndef EBCDIC
5037                case 0x2028:                case 0x2028:
5038                case 0x2029:                case 0x2029:
5039    #endif  /* Not EBCDIC */
5040                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
5041                break;                break;
5042                }                }
# Line 5004  for (;;) Line 5045  for (;;)
5045              case OP_NOT_HSPACE:              case OP_NOT_HSPACE:
5046              switch(c)              switch(c)
5047                {                {
5048                  HSPACE_CASES: RRETURN(MATCH_NOMATCH);
5049                default: break;                default: break;
               case 0x09:      /* HT */  
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
               case 0x1680:    /* OGHAM SPACE MARK */  
               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
               case 0x2000:    /* EN QUAD */  
               case 0x2001:    /* EM QUAD */  
               case 0x2002:    /* EN SPACE */  
               case 0x2003:    /* EM SPACE */  
               case 0x2004:    /* THREE-PER-EM SPACE */  
               case 0x2005:    /* FOUR-PER-EM SPACE */  
               case 0x2006:    /* SIX-PER-EM SPACE */  
               case 0x2007:    /* FIGURE SPACE */  
               case 0x2008:    /* PUNCTUATION SPACE */  
               case 0x2009:    /* THIN SPACE */  
               case 0x200A:    /* HAIR SPACE */  
               case 0x202f:    /* NARROW NO-BREAK SPACE */  
               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
               case 0x3000:    /* IDEOGRAPHIC SPACE */  
               RRETURN(MATCH_NOMATCH);  
5050                }                }
5051              break;              break;
5052    
5053              case OP_HSPACE:              case OP_HSPACE:
5054              switch(c)              switch(c)
5055                {                {
5056                  HSPACE_CASES: break;
5057                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
               case 0x09:      /* HT */  
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
               case 0x1680:    /* OGHAM SPACE MARK */  
               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
               case 0x2000:    /* EN QUAD */  
               case 0x2001:    /* EM QUAD */  
               case 0x2002:    /* EN SPACE */  
               case 0x2003:    /* EM SPACE */  
               case 0x2004:    /* THREE-PER-EM SPACE */  
               case 0x2005:    /* FOUR-PER-EM SPACE */  
               case 0x2006:    /* SIX-PER-EM SPACE */  
               case 0x2007:    /* FIGURE SPACE */  
               case 0x2008:    /* PUNCTUATION SPACE */  
               case 0x2009:    /* THIN SPACE */  
               case 0x200A:    /* HAIR SPACE */  
               case 0x202f:    /* NARROW NO-BREAK SPACE */  
               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
               case 0x3000:    /* IDEOGRAPHIC SPACE */  
               break;  
5058                }                }
5059              break;              break;
5060    
5061              case OP_NOT_VSPACE:              case OP_NOT_VSPACE:
5062              switch(c)              switch(c)
5063                {                {
5064                  VSPACE_CASES: RRETURN(MATCH_NOMATCH);
5065                default: break;                default: break;
               case 0x0a:      /* LF */  
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
               case 0x2028:    /* LINE SEPARATOR */  
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
               RRETURN(MATCH_NOMATCH);  
5066                }                }
5067              break;              break;
5068    
5069              case OP_VSPACE:              case OP_VSPACE:
5070              switch(c)              switch(c)
5071                {                {
5072                  VSPACE_CASES: break;
5073                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
               case 0x0a:      /* LF */  
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
               case 0x2028:    /* LINE SEPARATOR */  
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
               break;  
5074                }                }
5075              break;              break;
5076    
# Line 5139  for (;;) Line 5128  for (;;)
5128            c = *eptr++;            c = *eptr++;
5129            switch(ctype)            switch(ctype)
5130              {              {
5131              case OP_ANY:     /* This is the non-NL case */              case OP_ANY:               /* This is the non-NL case */
5132                if (md->partial != 0 &&    /* Take care with CRLF partial */
5133                    eptr >= md->end_subject &&
5134                    NLBLOCK->nltype == NLTYPE_FIXED &&
5135                    NLBLOCK->nllen == 2 &&
5136                    c == NLBLOCK->nl[0])
5137                  {
5138                  md->hitend = TRUE;
5139                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5140                  }
5141                break;
5142    
5143              case OP_ALLANY:              case OP_ALLANY:
5144              case OP_ANYBYTE:              case OP_ANYBYTE:
5145              break;              break;
# Line 5148  for (;;) Line 5148  for (;;)
5148              switch(c)              switch(c)
5149                {                {
5150                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5151                case 0x000d:                case CHAR_CR:
5152                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5153                break;                break;
5154    
5155                case 0x000a:                case CHAR_LF:
5156                break;                break;
5157    
5158                case 0x000b:                case CHAR_VT:
5159                case 0x000c:                case CHAR_FF:
5160                case 0x0085:                case CHAR_NEL:
5161  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5162                case 0x2028:                case 0x2028:
5163                case 0x2029:                case 0x2029:
# Line 5171  for (;;) Line 5171  for (;;)
5171              switch(c)              switch(c)
5172                {                {
5173                default: break;                default: break;
5174                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
5175  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5176                case 0x1680:    /* OGHAM SPACE MARK */                HSPACE_MULTIBYTE_CASES:
               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
               case 0x2000:    /* EN QUAD */  
               case 0x2001:    /* EM QUAD */  
               case 0x2002:    /* EN SPACE */  
               case 0x2003:    /* EM SPACE */  
               case 0x2004:    /* THREE-PER-EM SPACE */  
               case 0x2005:    /* FOUR-PER-EM SPACE */  
               case 0x2006:    /* SIX-PER-EM SPACE */  
               case 0x2007:    /* FIGURE SPACE */  
               case 0x2008:    /* PUNCTUATION SPACE */  
               case 0x2009:    /* THIN SPACE */  
               case 0x200A:    /* HAIR SPACE */  
               case 0x202f:    /* NARROW NO-BREAK SPACE */  
               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
               case 0x3000:    /* IDEOGRAPHIC SPACE */  
5177  #endif  #endif
5178                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5179                }                }
# Line 5200  for (;;) Line 5183  for (;;)
5183              switch(c)              switch(c)
5184                {                {
5185                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5186                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
5187  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5188                case 0x1680:    /* OGHAM SPACE MARK */                HSPACE_MULTIBYTE_CASES:
               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
               case 0x2000:    /* EN QUAD */  
               case 0x2001:    /* EM QUAD */  
               case 0x2002:    /* EN SPACE */  
               case 0x2003:    /* EM SPACE */  
               case 0x2004:    /* THREE-PER-EM SPACE */  
               case 0x2005:    /* FOUR-PER-EM SPACE */  
               case 0x2006:    /* SIX-PER-EM SPACE */  
               case 0x2007:    /* FIGURE SPACE */  
               case 0x2008:    /* PUNCTUATION SPACE */  
               case 0x2009:    /* THIN SPACE */  
               case 0x200A:    /* HAIR SPACE */  
               case 0x202f:    /* NARROW NO-BREAK SPACE */  
               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
               case 0x3000:    /* IDEOGRAPHIC SPACE */  
5189  #endif  #endif
5190                break;                break;
5191                }                }
# Line 5229  for (;;) Line 5195  for (;;)
5195              switch(c)              switch(c)
5196                {                {
5197                default: break;                default: break;
5198                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
5199  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5200                case 0x2028:    /* LINE SEPARATOR */                VSPACE_MULTIBYTE_CASES:
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5201  #endif  #endif
5202                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5203                }                }
# Line 5246  for (;;) Line 5207  for (;;)
5207              switch(c)              switch(c)
5208                {                {
5209                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5210                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
5211  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5212                case 0x2028:    /* LINE SEPARATOR */                VSPACE_MULTIBYTE_CASES:
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5213  #endif  #endif
5214                break;                break;
5215                }                }
# Line 5456  for (;;) Line 5412  for (;;)
5412              eptr+= len;              eptr+= len;
5413              }              }
5414            break;            break;
5415    
5416              case PT_CLIST:
5417              for (i = min; i < max; i++)
5418                {
5419                const pcre_uint32 *cp;
5420                int len = 1;
5421                if (eptr >= md->end_subject)
5422                  {
5423                  SCHECK_PARTIAL();
5424                  break;
5425                  }
5426                GETCHARLENTEST(c, eptr, len);
5427                cp = PRIV(ucd_caseless_sets) + UCD_CASESET(c);
5428                for (;;)
5429                  {
5430                  if (c < *cp)
5431                    { if (prop_fail_result) break; else goto GOT_MAX; }
5432                  if (c == *cp++)
5433                    { if (prop_fail_result) goto GOT_MAX; else break; }
5434                  }
5435                eptr += len;
5436                }
5437              GOT_MAX:
5438              break;
5439    
5440            default:            default:
5441            RRETURN(PCRE_ERROR_INTERNAL);            RRETURN(PCRE_ERROR_INTERNAL);
# Line 5480  for (;;) Line 5460  for (;;)
5460          {          {
5461          for (i = min; i < max; i++)          for (i = min; i < max; i++)
5462            {            {
           int len = 1;  
5463            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
5464              {              {
5465              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5466              break;              break;
5467              }              }
5468            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }            else
           if (UCD_CATEGORY(c) == ucp_M) break;  
           eptr += len;  
           while (eptr < md->end_subject)  
5469              {              {
5470              len = 1;              int lgb, rgb;
5471              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
5472              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
5473              eptr += len;              while (eptr < md->end_subject)
5474                  {
5475                  int len = 1;
5476                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5477                  rgb = UCD_GRAPHBREAK(c);
5478                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5479                  lgb = rgb;
5480                  eptr += len;
5481                  }
5482              }              }
5483              CHECK_PARTIAL();
5484            }            }
5485    
5486          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5539  for (;;) Line 5524  for (;;)
5524                  break;                  break;
5525                  }                  }
5526                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
5527                  if (md->partial != 0 &&    /* Take care with CRLF partial */
5528                      eptr + 1 >= md->end_subject &&
5529                      NLBLOCK->nltype == NLTYPE_FIXED &&
5530                      NLBLOCK->nllen == 2 &&
5531                      *eptr == NLBLOCK->nl[0])
5532                    {
5533                    md->hitend = TRUE;
5534                    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5535                    }
5536                eptr++;                eptr++;
5537                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5538                }                }
# Line 5556  for (;;) Line 5550  for (;;)
5550                  break;                  break;
5551                  }                  }
5552                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
5553                  if (md->partial != 0 &&    /* Take care with CRLF partial */
5554                      eptr + 1 >= md->end_subject &&
5555                      NLBLOCK->nltype == NLTYPE_FIXED &&
5556                      NLBLOCK->nllen == 2 &&
5557                      *eptr == NLBLOCK->nl[0])
5558                    {
5559                    md->hitend = TRUE;
5560                    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5561                    }
5562                eptr++;                eptr++;
5563                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5564                }                }
# Line 5605  for (;;) Line 5608  for (;;)
5608                break;                break;
5609                }                }
5610              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5611              if (c == 0x000d)              if (c == CHAR_CR)
5612                {                {
5613                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5614                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5615                }                }
5616              else              else
5617                {                {
5618                if (c != 0x000a &&                if (c != CHAR_LF &&
5619                    (md->bsr_anycrlf ||                    (md->bsr_anycrlf ||
5620                     (c != 0x000b && c != 0x000c &&                     (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5621                      c != 0x0085 && c != 0x2028 && c != 0x2029)))  #ifndef EBCDIC
5622                        && c != 0x2028 && c != 0x2029
5623    #endif  /* Not EBCDIC */
5624                        )))
5625                  break;                  break;
5626                eptr += len;                eptr += len;
5627                }                }
# Line 5636  for (;;) Line 5642  for (;;)
5642              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5643              switch(c)              switch(c)
5644                {                {
5645                  HSPACE_CASES: gotspace = TRUE; break;
5646                default: gotspace = FALSE; break;                default: gotspace = FALSE; break;
               case 0x09:      /* HT */  
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
               case 0x1680:    /* OGHAM SPACE MARK */  
               case 0x180e:    /* MONGOLIAN VOWEL SEPARATOR */  
               case 0x2000:    /* EN QUAD */  
               case 0x2001:    /* EM QUAD */  
               case 0x2002:    /* EN SPACE */  
               case 0x2003:    /* EM SPACE */  
               case 0x2004:    /* THREE-PER-EM SPACE */  
               case 0x2005:    /* FOUR-PER-EM SPACE */  
               case 0x2006:    /* SIX-PER-EM SPACE */  
               case 0x2007:    /* FIGURE SPACE */  
               case 0x2008:    /* PUNCTUATION SPACE */  
               case 0x2009:    /* THIN SPACE */  
               case 0x200A:    /* HAIR SPACE */  
               case 0x202f:    /* NARROW NO-BREAK SPACE */  
               case 0x205f:    /* MEDIUM MATHEMATICAL SPACE */  
               case 0x3000:    /* IDEOGRAPHIC SPACE */  
               gotspace = TRUE;  
               break;  
5647                }                }
5648              if (gotspace == (ctype == OP_NOT_HSPACE)) break;              if (gotspace == (ctype == OP_NOT_HSPACE)) break;
5649              eptr += len;              eptr += len;
# Line 5678  for (;;) Line 5664  for (;;)
5664              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5665              switch(c)              switch(c)
5666                {                {
5667                  VSPACE_CASES: gotspace = TRUE; break;
5668                default: gotspace = FALSE; break;                default: gotspace = FALSE; break;
               case 0x0a:      /* LF */  
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
               case 0x2028:    /* LINE SEPARATOR */  
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
               gotspace = TRUE;  
               break;  
5669                }                }
5670              if (gotspace == (ctype == OP_NOT_VSPACE)) break;              if (gotspace == (ctype == OP_NOT_VSPACE)) break;
5671              eptr += len;              eptr += len;
# Line 5801  for (;;) Line 5779  for (;;)
5779            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5780            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5781            BACKCHAR(eptr);            BACKCHAR(eptr);
5782            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_NL &&
5783                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
5784            }            }
5785          }          }
5786        else        else
# Line 5820  for (;;) Line 5798  for (;;)
5798                break;                break;
5799                }                }
5800              if (IS_NEWLINE(eptr)) break;              if (IS_NEWLINE(eptr)) break;
5801                if (md->partial != 0 &&    /* Take care with CRLF partial */
5802                    eptr + 1 >= md->end_subject &&
5803                    NLBLOCK->nltype == NLTYPE_FIXED &&
5804                    NLBLOCK->nllen == 2 &&
5805                    *eptr == NLBLOCK->nl[0])
5806                  {
5807                  md->hitend = TRUE;
5808                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5809                  }
5810              eptr++;              eptr++;
5811              }              }
5812            break;            break;
# Line 5844  for (;;) Line 5831  for (;;)
5831                break;                break;
5832                }                }
5833              c = *eptr;              c = *eptr;
5834              if (c == 0x000d)              if (c == CHAR_CR)
5835                {                {
5836                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5837                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5838                }                }
5839              else              else
5840                {                {
5841                if (c != 0x000a && (md->bsr_anycrlf ||                if (c != CHAR_LF && (md->bsr_anycrlf ||
5842                  (c != 0x000b && c != 0x000c && c != 0x0085                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5843  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5844                  && c != 0x2028 && c != 0x2029                   && c != 0x2028 && c != 0x2029
5845  #endif  #endif
5846                  ))) break;                   ))) break;
5847                eptr++;                eptr++;
5848                }                }
5849              }              }
# Line 5870  for (;;) Line 5857  for (;;)
5857                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5858                break;                break;
5859                }                }
5860              c = *eptr;              switch(*eptr)
5861              if (c == 0x09 || c == 0x20 || c == 0xa0                {
5862                  default: eptr++; break;
5863                  HSPACE_BYTE_CASES:
5864  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5865                || c == 0x1680 || c == 0x180e || (c >= 0x2000 && c <= 0x200A)                HSPACE_MULTIBYTE_CASES:
               || c == 0x202f || c == 0x205f || c == 0x3000  
5866  #endif  #endif
5867                ) break;                goto ENDLOOP00;
5868              eptr++;                }
5869              }              }
5870              ENDLOOP00:
5871            break;            break;
5872    
5873            case OP_HSPACE:            case OP_HSPACE:
# Line 5889  for (;;) Line 5878  for (;;)
5878                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5879                break;                break;
5880                }                }
5881              c = *eptr;              switch(*eptr)
5882              if (c != 0x09 && c != 0x20 && c != 0xa0                {
5883                  default: goto ENDLOOP01;
5884                  HSPACE_BYTE_CASES:
5885  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5886                && c != 0x1680 && c != 0x180e && (c < 0x2000 || c > 0x200A)                HSPACE_MULTIBYTE_CASES:
               && c != 0x202f && c != 0x205f && c != 0x3000  
5887  #endif  #endif
5888                ) break;                eptr++; break;
5889              eptr++;                }
5890              }              }
5891              ENDLOOP01:
5892            break;            break;
5893    
5894            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
# Line 5908  for (;;) Line 5899  for (;;)
5899                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5900                break;                break;
5901                }                }
5902              c = *eptr;              switch(*eptr)
5903              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85                {
5904                  default: eptr++; break;
5905                  VSPACE_BYTE_CASES:
5906  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5907                || c == 0x2028 || c == 0x2029                VSPACE_MULTIBYTE_CASES:
5908  #endif  #endif
5909                ) break;                goto ENDLOOP02;
5910              eptr++;                }
5911              }              }
5912              ENDLOOP02:
5913            break;            break;
5914    
5915            case OP_VSPACE:            case OP_VSPACE:
# Line 5926  for (;;) Line 5920  for (;;)
5920                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5921                break;                break;
5922                }                }
5923              c = *eptr;              switch(*eptr)
5924              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85                {
5925                  default: goto ENDLOOP03;
5926                  VSPACE_BYTE_CASES:
5927  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5928                && c != 0x2028 && c != 0x2029                VSPACE_MULTIBYTE_CASES:
5929  #endif  #endif
5930                ) break;                eptr++; break;
5931              eptr++;                }
5932              }              }
5933              ENDLOOP03:
5934            break;            break;
5935    
5936            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
# Line 6030  for (;;) Line 6027  for (;;)
6027            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
6028            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
6029            eptr--;            eptr--;
6030            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_LF &&
6031                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
6032            }            }
6033          }          }
6034    
# Line 6150  Undefine all the macros that were define Line 6147  Undefine all the macros that were define
6147  ***************************************************************************/  ***************************************************************************/
6148    
6149    
6150    #ifdef NO_RECURSE
6151    /*************************************************
6152    *          Release allocated heap frames         *
6153    *************************************************/
6154    
6155    /* This function releases all the allocated frames. The base frame is on the
6156    machine stack, and so must not be freed.
6157    
6158    Argument: the address of the base frame
6159    Returns:  nothing
6160    */
6161    
6162    static void
6163    release_match_heapframes (heapframe *frame_base)
6164    {
6165    heapframe *nextframe = frame_base->Xnextframe;
6166    while (nextframe != NULL)
6167      {
6168      heapframe *oldframe = nextframe;
6169      nextframe = nextframe->Xnextframe;
6170      (PUBL(stack_free))(oldframe);
6171      }
6172    }
6173    #endif
6174    
6175    
6176  /*************************************************  /*************************************************
6177  *         Execute a Regular Expression           *  *         Execute a Regular Expression           *
# Line 6212  PCRE_PUCHAR req_char_ptr = start_match - Line 6234  PCRE_PUCHAR req_char_ptr = start_match -
6234  const pcre_study_data *study;  const pcre_study_data *study;
6235  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
6236    
6237  /* Check for the special magic call that measures the size of the stack used  #ifdef NO_RECURSE
6238  per recursive call of match(). */  heapframe frame_zero;
6239    frame_zero.Xprevframe = NULL;            /* Marks the top level */
6240    frame_zero.Xnextframe = NULL;            /* None are allocated yet */
6241    md->match_frames_base = &frame_zero;
6242    #endif
6243    
6244  if (re == NULL && extra_data == NULL && subject == NULL && length == -1)  /* Check for the special magic call that measures the size of the stack used
6245    per recursive call of match(). Without the funny casting for sizeof, a Windows
6246    compiler gave this error: "unary minus operator applied to unsigned type,
6247    result still unsigned". Hopefully the cast fixes that. */
6248    
6249    if (re == NULL && extra_data == NULL && subject == NULL && length == -999 &&
6250        start_offset == -999)
6251  #ifdef NO_RECURSE  #ifdef NO_RECURSE
6252    return -sizeof(heapframe);    return -((int)sizeof(heapframe));
6253  #else  #else
6254    return match((PCRE_PUCHAR)&start_partial, NULL, NULL, 0, NULL, NULL, 0);    return match(NULL, NULL, NULL, 0, NULL, NULL, 0);
6255  #endif  #endif
6256    
6257  /* Plausibility checks */  /* Plausibility checks */
6258    
6259  if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;  if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
6260  if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))  if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))
6261    return PCRE_ERROR_NULL;    return PCRE_ERROR_NULL;
6262  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
6263  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
# Line 6284  if (utf && (options & PCRE_NO_UTF8_CHECK Line 6316  if (utf && (options & PCRE_NO_UTF8_CHECK
6316  /* If the pattern was successfully studied with JIT support, run the JIT  /* If the pattern was successfully studied with JIT support, run the JIT
6317  executable instead of the rest of this function. Most options must be set at  executable instead of the rest of this function. Most options must be set at
6318  compile time for the JIT code to be usable. Fallback to the normal code path if  compile time for the JIT code to be usable. Fallback to the normal code path if
6319  an unsupported flag is set. In particular, JIT does not support partial  an unsupported flag is set. */
 matching. */  
6320    
6321  #ifdef SUPPORT_JIT  #ifdef SUPPORT_JIT
6322  if (extra_data != NULL  if (extra_data != NULL
6323      && (extra_data->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0      && (extra_data->flags & (PCRE_EXTRA_EXECUTABLE_JIT |
6324                                 PCRE_EXTRA_TABLES)) == PCRE_EXTRA_EXECUTABLE_JIT
6325      && extra_data->executable_jit != NULL      && extra_data->executable_jit != NULL
     && (extra_data->flags & PCRE_EXTRA_TABLES) == 0  
6326      && (options & ~(PCRE_NO_UTF8_CHECK | PCRE_NOTBOL | PCRE_NOTEOL |      && (options & ~(PCRE_NO_UTF8_CHECK | PCRE_NOTBOL | PCRE_NOTEOL |
6327                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART)) == 0)                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |
6328    return PRIV(jit_exec)(re, extra_data->executable_jit,                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)
6329      (const pcre_uchar *)subject, length, start_offset, options,    {
6330      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)    rc = PRIV(jit_exec)(re, extra_data, (const pcre_uchar *)subject, length,
6331      ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);         start_offset, options, offsets, offsetcount);
6332    
6333      /* PCRE_ERROR_NULL means that the selected normal or partial matching
6334      mode is not compiled. In this case we simply fallback to interpreter. */
6335    
6336      if (rc != PCRE_ERROR_NULL) return rc;
6337      }
6338  #endif  #endif
6339    
6340  /* Carry on with non-JIT matching. This information is for finding all the  /* Carry on with non-JIT matching. This information is for finding all the
# Line 6500  if (!anchored) Line 6537  if (!anchored)
6537    if ((re->flags & PCRE_FIRSTSET) != 0)    if ((re->flags & PCRE_FIRSTSET) != 0)
6538      {      {
6539      has_first_char = TRUE;      has_first_char = TRUE;
6540      first_char = first_char2 = re->first_char;      first_char = first_char2 = (pcre_uchar)(re->first_char);
6541      if ((re->flags & PCRE_FCH_CASELESS) != 0)      if ((re->flags & PCRE_FCH_CASELESS) != 0)
6542        {        {
6543        first_char2 = TABLE_GET(first_char, md->fcc, first_char);        first_char2 = TABLE_GET(first_char, md->fcc, first_char);
# Line 6522  character" set. */ Line 6559  character" set. */
6559  if ((re->flags & PCRE_REQCHSET) != 0)  if ((re->flags & PCRE_REQCHSET) != 0)
6560    {    {
6561    has_req_char = TRUE;    has_req_char = TRUE;
6562    req_char = req_char2 = re->req_char;    req_char = req_char2 = (pcre_uchar)(re->req_char);
6563    if ((re->flags & PCRE_RCH_CASELESS) != 0)    if ((re->flags & PCRE_RCH_CASELESS) != 0)
6564      {      {
6565      req_char2 = TABLE_GET(req_char, md->fcc, req_char);      req_char2 = TABLE_GET(req_char, md->fcc, req_char);
# Line 6891  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6928  if (rc == MATCH_MATCH || rc == MATCH_ACC
6928      {      {
6929      register int *iptr, *iend;      register int *iptr, *iend;
6930      int resetcount = 2 + re->top_bracket * 2;      int resetcount = 2 + re->top_bracket * 2;
6931      if (resetcount > offsetcount) resetcount = ocount;      if (resetcount > offsetcount) resetcount = offsetcount;
6932      iptr = offsets + md->end_offset_top;      iptr = offsets + md->end_offset_top;
6933      iend = offsets + resetcount;      iend = offsets + resetcount;
6934      while (iptr < iend) *iptr++ = -1;      while (iptr < iend) *iptr++ = -1;
# Line 6912  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6949  if (rc == MATCH_MATCH || rc == MATCH_ACC
6949    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6950      *(extra_data->mark) = (pcre_uchar *)md->mark;      *(extra_data->mark) = (pcre_uchar *)md->mark;
6951    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
6952    #ifdef NO_RECURSE
6953      release_match_heapframes(&frame_zero);
6954    #endif
6955    return rc;    return rc;
6956    }    }
6957    
# Line 6929  if (using_temporary_offsets) Line 6969  if (using_temporary_offsets)
6969  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
6970    {    {
6971    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
6972    #ifdef NO_RECURSE
6973      release_match_heapframes(&frame_zero);
6974    #endif
6975    return rc;    return rc;
6976    }    }
6977    
# Line 6958  else Line 7001  else
7001    
7002  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
7003    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;
7004    #ifdef NO_RECURSE
7005      release_match_heapframes(&frame_zero);
7006    #endif
7007  return rc;  return rc;
7008  }  }
7009    

Legend:
Removed from v.893  
changed lines
  Added in v.1046

  ViewVC Help
Powered by ViewVC 1.1.5