/[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 882 by ph10, Sun Jan 15 18:45:27 2012 UTC revision 1041 by ph10, Sun Sep 16 10:16:27 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 189  if (caseless) Line 191  if (caseless)
191      while (p < endptr)      while (p < endptr)
192        {        {
193        int c, d;        int c, d;
194        if (eptr >= md->end_subject) return -1;        if (eptr >= md->end_subject) return -2;   /* Partial match */
195        GETCHARINC(c, eptr);        GETCHARINC(c, eptr);
196        GETCHARINC(d, p);        GETCHARINC(d, p);
197        if (c != d && c != UCD_OTHERCASE(d)) return -1;        if (c != d && c != UCD_OTHERCASE(d)) return -1;
# Line 202  if (caseless) Line 204  if (caseless)
204    /* 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
205    is no UCP support. */    is no UCP support. */
206      {      {
     if (eptr + length > md->end_subject) return -1;  
207      while (length-- > 0)      while (length-- > 0)
208        {        {
209          if (eptr >= md->end_subject) return -2;   /* Partial match */
210        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;
211        p++;        p++;
212        eptr++;        eptr++;
# Line 217  are in UTF-8 mode. */ Line 219  are in UTF-8 mode. */
219    
220  else  else
221    {    {
222    if (eptr + length > md->end_subject) return -1;    while (length-- > 0)
223    while (length-- > 0) if (*p++ != *eptr++) return -1;      {
224        if (eptr >= md->end_subject) return -2;   /* Partial match */
225        if (*p++ != *eptr++) return -1;
226        }
227    }    }
228    
229  return (int)(eptr - eptr_start);  return (int)(eptr - eptr_start);
# Line 311  argument of match(), which never changes Line 316  argument of match(), which never changes
316    
317  #define RMATCH(ra,rb,rc,rd,re,rw)\  #define RMATCH(ra,rb,rc,rd,re,rw)\
318    {\    {\
319    heapframe *newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\    heapframe *newframe = frame->Xnextframe;\
320    if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\    if (newframe == NULL)\
321    frame->Xwhere = rw; \      {\
322        newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
323        if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
324        newframe->Xnextframe = NULL;\
325        frame->Xnextframe = newframe;\
326        }\
327      frame->Xwhere = rw;\
328    newframe->Xeptr = ra;\    newframe->Xeptr = ra;\
329    newframe->Xecode = rb;\    newframe->Xecode = rb;\
330    newframe->Xmstart = mstart;\    newframe->Xmstart = mstart;\
# Line 332  argument of match(), which never changes Line 343  argument of match(), which never changes
343    {\    {\
344    heapframe *oldframe = frame;\    heapframe *oldframe = frame;\
345    frame = oldframe->Xprevframe;\    frame = oldframe->Xprevframe;\
   (PUBL(stack_free))(oldframe);\  
346    if (frame != NULL)\    if (frame != NULL)\
347      {\      {\
348      rrc = ra;\      rrc = ra;\
# Line 346  argument of match(), which never changes Line 356  argument of match(), which never changes
356    
357  typedef struct heapframe {  typedef struct heapframe {
358    struct heapframe *Xprevframe;    struct heapframe *Xprevframe;
359      struct heapframe *Xnextframe;
360    
361    /* Function arguments that may change */    /* Function arguments that may change */
362    
# Line 485  BOOL caseless; Line 496  BOOL caseless;
496  int condcode;  int condcode;
497    
498  /* 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
499  preserved over calls to RMATCH() are part of a "frame" which is obtained from  preserved over calls to RMATCH() are part of a "frame". We set up the top-level
500  heap storage. Set up the top-level frame here; others are obtained from the  frame on the stack here; subsequent instantiations are obtained from the heap
501  heap whenever RMATCH() does a "recursion". See the macro definitions above. */  whenever RMATCH() does a "recursion". See the macro definitions above. Putting
502    the top-level on the stack rather than malloc-ing them all gives a performance
503    boost in many cases where there is not much "recursion". */
504    
505  #ifdef NO_RECURSE  #ifdef NO_RECURSE
506  heapframe *frame = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));  heapframe *frame = (heapframe *)md->match_frames_base;
 if (frame == NULL) RRETURN(PCRE_ERROR_NOMEMORY);  
 frame->Xprevframe = NULL;            /* Marks the top level */  
507    
508  /* Copy in the original argument variables */  /* Copy in the original argument variables */
509    
# Line 613  int save_offset1, save_offset2, save_off Line 624  int save_offset1, save_offset2, save_off
624  int stacksave[REC_STACK_SAVE_MAX];  int stacksave[REC_STACK_SAVE_MAX];
625    
626  eptrblock newptrb;  eptrblock newptrb;
627    
628    /* There is a special fudge for calling match() in a way that causes it to
629    measure the size of its basic stack frame when the stack is being used for
630    recursion. The second argument (ecode) being NULL triggers this behaviour. It
631    cannot normally ever be NULL. The return is the negated value of the frame
632    size. */
633    
634    if (ecode == NULL)
635      {
636      if (rdepth == 0)
637        return match((PCRE_PUCHAR)&rdepth, NULL, NULL, 0, NULL, NULL, 1);
638      else
639        {
640        int len = (char *)&rdepth - (char *)eptr;
641        return (len > 0)? -len : len;
642        }
643      }
644  #endif     /* NO_RECURSE */  #endif     /* NO_RECURSE */
645    
646  /* 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 819  for (;;) Line 847  for (;;)
847      case OP_ONCE_NC:      case OP_ONCE_NC:
848      prev = ecode;      prev = ecode;
849      saved_eptr = eptr;      saved_eptr = eptr;
850      save_mark = md->mark;      save_mark = md->mark;
851      do      do
852        {        {
853        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
# Line 838  for (;;) Line 866  for (;;)
866    
867        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
868        ecode += GET(ecode,1);        ecode += GET(ecode,1);
869        md->mark = save_mark;        md->mark = save_mark;
870        }        }
871      while (*ecode == OP_ALT);      while (*ecode == OP_ALT);
872    
# Line 878  for (;;) Line 906  for (;;)
906        }        }
907      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
908        {        {
       md->match_function_type = MATCH_CBEGROUP;  
909        RMATCH(eptr, prev, offset_top, md, eptrb, RM66);        RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
910        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
911        ecode += 1 + LINK_SIZE;        ecode += 1 + LINK_SIZE;
# Line 918  for (;;) Line 945  for (;;)
945        save_offset2 = md->offset_vector[offset+1];        save_offset2 = md->offset_vector[offset+1];
946        save_offset3 = md->offset_vector[md->offset_end - number];        save_offset3 = md->offset_vector[md->offset_end - number];
947        save_capture_last = md->capture_last;        save_capture_last = md->capture_last;
948        save_mark = md->mark;        save_mark = md->mark;
949    
950        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));        DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
951        md->offset_vector[md->offset_end - number] =        md->offset_vector[md->offset_end - number] =
# Line 1007  for (;;) Line 1034  for (;;)
1034    
1035      for (;;)      for (;;)
1036        {        {
1037        if (op >= OP_SBRA || op == OP_ONCE) md->match_function_type = MATCH_CBEGROUP;        if (op >= OP_SBRA || op == OP_ONCE)
1038            md->match_function_type = MATCH_CBEGROUP;
1039    
1040        /* 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
1041        the pattern, and this is the final alternative, optimize as described        the pattern, and this is the final alternative, optimize as described
# Line 1024  for (;;) Line 1052  for (;;)
1052        save_mark = md->mark;        save_mark = md->mark;
1053        RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,        RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,
1054          RM2);          RM2);
1055    
1056        /* See comment in the code for capturing groups above about handling        /* See comment in the code for capturing groups above about handling
1057        THEN. */        THEN. */
1058    
# Line 1051  for (;;) Line 1079  for (;;)
1079          RRETURN(rrc);          RRETURN(rrc);
1080          }          }
1081        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
1082        md->mark = save_mark;        md->mark = save_mark;
1083        if (*ecode != OP_ALT) break;        if (*ecode != OP_ALT) break;
1084        }        }
1085    
# Line 1530  for (;;) Line 1558  for (;;)
1558    
1559      case OP_ASSERT:      case OP_ASSERT:
1560      case OP_ASSERTBACK:      case OP_ASSERTBACK:
1561        save_mark = md->mark;
1562      if (md->match_function_type == MATCH_CONDASSERT)      if (md->match_function_type == MATCH_CONDASSERT)
1563        {        {
1564        condassert = TRUE;        condassert = TRUE;
# Line 1545  for (;;) Line 1574  for (;;)
1574          mstart = md->start_match_ptr;   /* In case \K reset it */          mstart = md->start_match_ptr;   /* In case \K reset it */
1575          break;          break;
1576          }          }
1577          md->mark = save_mark;
1578    
1579        /* PCRE does not allow THEN to escape beyond an assertion; it is treated        /* A COMMIT failure must fail the entire assertion, without trying any
1580        as NOMATCH. */        subsequent branches. */
1581    
1582          if (rrc == MATCH_COMMIT) RRETURN(MATCH_NOMATCH);
1583    
1584          /* PCRE does not allow THEN to escape beyond an assertion; it
1585          is treated as NOMATCH. */
1586    
1587        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);        if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc);
1588        ecode += GET(ecode, 1);        ecode += GET(ecode, 1);
# Line 1574  for (;;) Line 1609  for (;;)
1609    
1610      case OP_ASSERT_NOT:      case OP_ASSERT_NOT:
1611      case OP_ASSERTBACK_NOT:      case OP_ASSERTBACK_NOT:
1612        save_mark = md->mark;
1613      if (md->match_function_type == MATCH_CONDASSERT)      if (md->match_function_type == MATCH_CONDASSERT)
1614        {        {
1615        condassert = TRUE;        condassert = TRUE;
# Line 1584  for (;;) Line 1620  for (;;)
1620      do      do
1621        {        {
1622        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
1623          md->mark = save_mark;
1624        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) RRETURN(MATCH_NOMATCH);
1625        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)        if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT)
1626          {          {
# Line 1756  for (;;) Line 1793  for (;;)
1793            goto RECURSION_MATCHED;        /* Exit loop; end processing */            goto RECURSION_MATCHED;        /* Exit loop; end processing */
1794            }            }
1795    
1796          /* 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
1797          as NOMATCH. */          is treated as NOMATCH. */
1798    
1799          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)          else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN &&
1800                     rrc != MATCH_COMMIT)
1801            {            {
1802            DPRINTF(("Recursion gave error %d\n", rrc));            DPRINTF(("Recursion gave error %d\n", rrc));
1803            if (new_recursive.offset_save != stacksave)            if (new_recursive.offset_save != stacksave)
# Line 1970  for (;;) Line 2008  for (;;)
2008          }          }
2009        if (*prev >= OP_SBRA)    /* Could match an empty string */        if (*prev >= OP_SBRA)    /* Could match an empty string */
2010          {          {
         md->match_function_type = MATCH_CBEGROUP;  
2011          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);          RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
2012          RRETURN(rrc);          RRETURN(rrc);
2013          }          }
# Line 1979  for (;;) Line 2016  for (;;)
2016        }        }
2017      else  /* OP_KETRMAX */      else  /* OP_KETRMAX */
2018        {        {
       if (*prev >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;  
2019        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);        RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
2020        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;        if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
2021        if (rrc != MATCH_NOMATCH) RRETURN(rrc);        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
# Line 2036  for (;;) Line 2072  for (;;)
2072    
2073      case OP_DOLLM:      case OP_DOLLM:
2074      if (eptr < md->end_subject)      if (eptr < md->end_subject)
2075        { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); }        {
2076          if (!IS_NEWLINE(eptr))
2077            {
2078            if (md->partial != 0 &&
2079                eptr + 1 >= md->end_subject &&
2080                NLBLOCK->nltype == NLTYPE_FIXED &&
2081                NLBLOCK->nllen == 2 &&
2082                *eptr == NLBLOCK->nl[0])
2083              {
2084              md->hitend = TRUE;
2085              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2086              }
2087            RRETURN(MATCH_NOMATCH);
2088            }
2089          }
2090      else      else
2091        {        {
2092        if (md->noteol) RRETURN(MATCH_NOMATCH);        if (md->noteol) RRETURN(MATCH_NOMATCH);
# Line 2068  for (;;) Line 2118  for (;;)
2118      ASSERT_NL_OR_EOS:      ASSERT_NL_OR_EOS:
2119      if (eptr < md->end_subject &&      if (eptr < md->end_subject &&
2120          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))          (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
2121          {
2122          if (md->partial != 0 &&
2123              eptr + 1 >= md->end_subject &&
2124              NLBLOCK->nltype == NLTYPE_FIXED &&
2125              NLBLOCK->nllen == 2 &&
2126              *eptr == NLBLOCK->nl[0])
2127            {
2128            md->hitend = TRUE;
2129            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2130            }
2131        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2132          }
2133    
2134      /* Either at end of string or \n before end. */      /* Either at end of string or \n before end. */
2135    
# Line 2196  for (;;) Line 2257  for (;;)
2257        }        }
2258      break;      break;
2259    
2260      /* Match a single character type; inline for speed */      /* Match any single character type except newline; have to take care with
2261        CRLF newlines and partial matching. */
2262    
2263      case OP_ANY:      case OP_ANY:
2264      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);      if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
2265        if (md->partial != 0 &&
2266            eptr + 1 >= md->end_subject &&
2267            NLBLOCK->nltype == NLTYPE_FIXED &&
2268            NLBLOCK->nllen == 2 &&
2269            *eptr == NLBLOCK->nl[0])
2270          {
2271          md->hitend = TRUE;
2272          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2273          }
2274    
2275      /* Fall through */      /* Fall through */
2276    
2277        /* Match any single character whatsoever. */
2278    
2279      case OP_ALLANY:      case OP_ALLANY:
2280      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 */
2281        {                            /* not be updated before SCHECK_PARTIAL. */        {                            /* not be updated before SCHECK_PARTIAL. */
# Line 2341  for (;;) Line 2415  for (;;)
2415        {        {
2416        default: RRETURN(MATCH_NOMATCH);        default: RRETURN(MATCH_NOMATCH);
2417    
2418        case 0x000d:        case CHAR_CR:
2419        if (eptr < md->end_subject && *eptr == 0x0a) eptr++;        if (eptr >= md->end_subject)
2420            {
2421            SCHECK_PARTIAL();
2422            }
2423          else if (*eptr == CHAR_LF) eptr++;
2424        break;        break;
2425    
2426        case 0x000a:        case CHAR_LF:
2427        break;        break;
2428    
2429        case 0x000b:        case CHAR_VT:
2430        case 0x000c:        case CHAR_FF:
2431        case 0x0085:        case CHAR_NEL:
2432    #ifndef EBCDIC
2433        case 0x2028:        case 0x2028:
2434        case 0x2029:        case 0x2029:
2435    #endif  /* Not EBCDIC */
2436        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);        if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
2437        break;        break;
2438        }        }
# Line 2368  for (;;) Line 2448  for (;;)
2448      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2449      switch(c)      switch(c)
2450        {        {
2451          HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
2452        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);  
2453        }        }
2454      ecode++;      ecode++;
2455      break;      break;
# Line 2402  for (;;) Line 2463  for (;;)
2463      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2464      switch(c)      switch(c)
2465        {        {
2466          HSPACE_CASES: break;  /* Byte and multibyte cases */
2467        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;  
2468        }        }
2469      ecode++;      ecode++;
2470      break;      break;
# Line 2436  for (;;) Line 2478  for (;;)
2478      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2479      switch(c)      switch(c)
2480        {        {
2481          VSPACE_CASES: RRETURN(MATCH_NOMATCH);
2482        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);  
2483        }        }
2484      ecode++;      ecode++;
2485      break;      break;
# Line 2458  for (;;) Line 2493  for (;;)
2493      GETCHARINCTEST(c, eptr);      GETCHARINCTEST(c, eptr);
2494      switch(c)      switch(c)
2495        {        {
2496          VSPACE_CASES: break;
2497        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;  
2498        }        }
2499      ecode++;      ecode++;
2500      break;      break;
# Line 2563  for (;;) Line 2591  for (;;)
2591        SCHECK_PARTIAL();        SCHECK_PARTIAL();
2592        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
2593        }        }
2594      GETCHARINCTEST(c, eptr);      else
     if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
     while (eptr < md->end_subject)  
2595        {        {
2596        int len = 1;        int lgb, rgb;
2597        if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }        GETCHARINCTEST(c, eptr);
2598        if (UCD_CATEGORY(c) != ucp_M) break;        lgb = UCD_GRAPHBREAK(c);
2599        eptr += len;        while (eptr < md->end_subject)
2600            {
2601            int len = 1;
2602            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
2603            rgb = UCD_GRAPHBREAK(c);
2604            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
2605            lgb = rgb;
2606            eptr += len;
2607            }
2608        }        }
2609        CHECK_PARTIAL();
2610      ecode++;      ecode++;
2611      break;      break;
2612  #endif  #endif
# Line 2637  for (;;) Line 2672  for (;;)
2672        default:               /* No repeat follows */        default:               /* No repeat follows */
2673        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
2674          {          {
2675            if (length == -2) eptr = md->end_subject;   /* Partial match */
2676          CHECK_PARTIAL();          CHECK_PARTIAL();
2677          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2678          }          }
# Line 2662  for (;;) Line 2698  for (;;)
2698        int slength;        int slength;
2699        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2700          {          {
2701            if (slength == -2) eptr = md->end_subject;   /* Partial match */
2702          CHECK_PARTIAL();          CHECK_PARTIAL();
2703          RRETURN(MATCH_NOMATCH);          RRETURN(MATCH_NOMATCH);
2704          }          }
# Line 2685  for (;;) Line 2722  for (;;)
2722          if (fi >= max) RRETURN(MATCH_NOMATCH);          if (fi >= max) RRETURN(MATCH_NOMATCH);
2723          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2724            {            {
2725              if (slength == -2) eptr = md->end_subject;   /* Partial match */
2726            CHECK_PARTIAL();            CHECK_PARTIAL();
2727            RRETURN(MATCH_NOMATCH);            RRETURN(MATCH_NOMATCH);
2728            }            }
# Line 2703  for (;;) Line 2741  for (;;)
2741          int slength;          int slength;
2742          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)          if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
2743            {            {
2744            CHECK_PARTIAL();            /* Can't use CHECK_PARTIAL because we don't want to update eptr in
2745              the soft partial matching case. */
2746    
2747              if (slength == -2 && md->partial != 0 &&
2748                  md->end_subject > md->start_used_ptr)
2749                {
2750                md->hitend = TRUE;
2751                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
2752                }
2753            break;            break;
2754            }            }
2755          eptr += slength;          eptr += slength;
2756          }          }
2757    
2758        while (eptr >= pp)        while (eptr >= pp)
2759          {          {
2760          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);          RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
# Line 3337  for (;;) Line 3384  for (;;)
3384      maximizing, find the maximum number of characters and work backwards. */      maximizing, find the maximum number of characters and work backwards. */
3385    
3386      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
3387        max, eptr));        max, (char *)eptr));
3388    
3389      if (op >= OP_STARI)  /* Caseless */      if (op >= OP_STARI)  /* Caseless */
3390        {        {
# Line 3481  for (;;) Line 3528  for (;;)
3528        SCHECK_PARTIAL();        SCHECK_PARTIAL();
3529        RRETURN(MATCH_NOMATCH);        RRETURN(MATCH_NOMATCH);
3530        }        }
     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  
3531  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3532        if (utf)
3533          {
3534          register unsigned int ch, och;
3535    
3536          ecode++;
3537          GETCHARINC(ch, ecode);
3538          GETCHARINC(c, eptr);
3539    
3540          if (op == OP_NOT)
3541            {
3542            if (ch == c) RRETURN(MATCH_NOMATCH);
3543            }
3544          else
3545            {
3546  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3547        if (utf && ch > 127)          if (ch > 127)
3548          och = UCD_OTHERCASE(ch);            och = UCD_OTHERCASE(ch);
3549  #else  #else
3550        if (utf && ch > 127)          if (ch > 127)
3551          och = ch;            och = ch;
3552  #endif /* SUPPORT_UCP */  #endif /* SUPPORT_UCP */
3553        else          else
3554  #endif /* SUPPORT_UTF */            och = TABLE_GET(ch, md->fcc, ch);
3555          och = TABLE_GET(ch, md->fcc, ch);          if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
3556  #endif /* COMPILE_PCRE8 */          }
       if (ch == c || och == c) RRETURN(MATCH_NOMATCH);  
3557        }        }
3558      else    /* Caseful */      else
3559    #endif
3560        {        {
3561        if (*ecode++ == c) RRETURN(MATCH_NOMATCH);        register unsigned int ch = ecode[1];
3562          c = *eptr++;
3563          if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
3564            RRETURN(MATCH_NOMATCH);
3565          ecode += 2;
3566        }        }
3567      break;      break;
3568    
# Line 3587  for (;;) Line 3642  for (;;)
3642      /* Common code for all repeated single-byte matches. */      /* Common code for all repeated single-byte matches. */
3643    
3644      REPEATNOTCHAR:      REPEATNOTCHAR:
3645      fc = *ecode++;      GETCHARINCTEST(fc, ecode);
3646    
3647      /* The code is duplicated for the caseless and caseful cases, for speed,      /* The code is duplicated for the caseless and caseful cases, for speed,
3648      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 3598  for (;;) Line 3653  for (;;)
3653      characters and work backwards. */      characters and work backwards. */
3654    
3655      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,
3656        max, eptr));        max, (char *)eptr));
3657    
3658      if (op >= OP_NOTSTARI)     /* Caseless */      if (op >= OP_NOTSTARI)     /* Caseless */
3659        {        {
 #ifdef COMPILE_PCRE8  
       /* fc must be < 128 if UTF is enabled. */  
       foc = md->fcc[fc];  
 #else  
3660  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3661  #ifdef SUPPORT_UCP  #ifdef SUPPORT_UCP
3662        if (utf && fc > 127)        if (utf && fc > 127)
# Line 3617  for (;;) Line 3668  for (;;)
3668        else        else
3669  #endif /* SUPPORT_UTF */  #endif /* SUPPORT_UTF */
3670          foc = TABLE_GET(fc, md->fcc, fc);          foc = TABLE_GET(fc, md->fcc, fc);
 #endif /* COMPILE_PCRE8 */  
3671    
3672  #ifdef SUPPORT_UTF  #ifdef SUPPORT_UTF
3673        if (utf)        if (utf)
# Line 3631  for (;;) Line 3681  for (;;)
3681              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
3682              }              }
3683            GETCHARINC(d, eptr);            GETCHARINC(d, eptr);
3684            if (fc == d || foc == d) RRETURN(MATCH_NOMATCH);            if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3685            }            }
3686          }          }
3687        else        else
# Line 3669  for (;;) Line 3719  for (;;)
3719                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
3720                }                }
3721              GETCHARINC(d, eptr);              GETCHARINC(d, eptr);
3722              if (fc == d || foc == d) RRETURN(MATCH_NOMATCH);              if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
3723              }              }
3724            }            }
3725          else          else
# Line 3712  for (;;) Line 3762  for (;;)
3762                break;                break;
3763                }                }
3764              GETCHARLEN(d, eptr, len);              GETCHARLEN(d, eptr, len);
3765              if (fc == d || foc == d) break;              if (fc == d || (unsigned int)foc == d) break;
3766              eptr += len;              eptr += len;
3767              }              }
3768          if (possessive) continue;            if (possessive) continue;
3769          for(;;)            for(;;)
3770              {              {
3771              RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);              RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);
3772              if (rrc != MATCH_NOMATCH) RRETURN(rrc);              if (rrc != MATCH_NOMATCH) RRETURN(rrc);
# Line 4132  for (;;) Line 4182  for (;;)
4182              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4183              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4184              }              }
4185            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4186              {              {
4187              int len = 1;              int lgb, rgb;
4188              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4189              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4190              eptr += len;             while (eptr < md->end_subject)
4191                  {
4192                  int len = 1;
4193                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4194                  rgb = UCD_GRAPHBREAK(c);
4195                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4196                  lgb = rgb;
4197                  eptr += len;
4198                  }
4199              }              }
4200              CHECK_PARTIAL();
4201            }            }
4202          }          }
4203    
# Line 4161  for (;;) Line 4218  for (;;)
4218              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4219              }              }
4220            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4221              if (md->partial != 0 &&
4222                  eptr + 1 >= md->end_subject &&
4223                  NLBLOCK->nltype == NLTYPE_FIXED &&
4224                  NLBLOCK->nllen == 2 &&
4225                  *eptr == NLBLOCK->nl[0])
4226                {
4227                md->hitend = TRUE;
4228                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4229                }
4230            eptr++;            eptr++;
4231            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
4232            }            }
# Line 4197  for (;;) Line 4263  for (;;)
4263              {              {
4264              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4265    
4266              case 0x000d:              case CHAR_CR:
4267              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4268              break;              break;
4269    
4270              case 0x000a:              case CHAR_LF:
4271              break;              break;
4272    
4273              case 0x000b:              case CHAR_VT:
4274              case 0x000c:              case CHAR_FF:
4275              case 0x0085:              case CHAR_NEL:
4276    #ifndef EBCDIC
4277              case 0x2028:              case 0x2028:
4278              case 0x2029:              case 0x2029:
4279    #endif  /* Not EBCDIC */
4280              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4281              break;              break;
4282              }              }
# Line 4226  for (;;) Line 4294  for (;;)
4294            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4295            switch(c)            switch(c)
4296              {              {
4297                HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
4298              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);  
4299              }              }
4300            }            }
4301          break;          break;
# Line 4262  for (;;) Line 4311  for (;;)
4311            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4312            switch(c)            switch(c)
4313              {              {
4314                HSPACE_CASES: break;  /* Byte and multibyte cases */
4315              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;  
4316              }              }
4317            }            }
4318          break;          break;
# Line 4298  for (;;) Line 4328  for (;;)
4328            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4329            switch(c)            switch(c)
4330              {              {
4331                VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4332              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);  
4333              }              }
4334            }            }
4335          break;          break;
# Line 4322  for (;;) Line 4345  for (;;)
4345            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4346            switch(c)            switch(c)
4347              {              {
4348                VSPACE_CASES: break;
4349              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;  
4350              }              }
4351            }            }
4352          break;          break;
# Line 4445  for (;;) Line 4461  for (;;)
4461              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4462              }              }
4463            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);            if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
4464              if (md->partial != 0 &&
4465                  eptr + 1 >= md->end_subject &&
4466                  NLBLOCK->nltype == NLTYPE_FIXED &&
4467                  NLBLOCK->nllen == 2 &&
4468                  *eptr == NLBLOCK->nl[0])
4469                {
4470                md->hitend = TRUE;
4471                if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4472                }
4473            eptr++;            eptr++;
4474            }            }
4475          break;          break;
# Line 4479  for (;;) Line 4504  for (;;)
4504              {              {
4505              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4506    
4507              case 0x000d:              case CHAR_CR:
4508              if (eptr < md->end_subject && *eptr == 0x0a) eptr++;              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4509              break;              break;
4510    
4511              case 0x000a:              case CHAR_LF:
4512              break;              break;
4513    
4514              case 0x000b:              case CHAR_VT:
4515              case 0x000c:              case CHAR_FF:
4516              case 0x0085:              case CHAR_NEL:
4517  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4518              case 0x2028:              case 0x2028:
4519              case 0x2029:              case 0x2029:
# Line 4510  for (;;) Line 4535  for (;;)
4535            switch(*eptr++)            switch(*eptr++)
4536              {              {
4537              default: break;              default: break;
4538              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
4539  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4540              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 */  
4541  #endif  #endif
4542              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4543              }              }
# Line 4547  for (;;) Line 4555  for (;;)
4555            switch(*eptr++)            switch(*eptr++)
4556              {              {
4557              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4558              case 0x09:      /* HT */              HSPACE_BYTE_CASES:
             case 0x20:      /* SPACE */  
             case 0xa0:      /* NBSP */  
4559  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4560              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 */  
4561  #endif  #endif
4562              break;              break;
4563              }              }
# Line 4583  for (;;) Line 4574  for (;;)
4574              }              }
4575            switch(*eptr++)            switch(*eptr++)
4576              {              {
4577              default: break;              VSPACE_BYTE_CASES:
             case 0x0a:      /* LF */  
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
4578  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4579              case 0x2028:    /* LINE SEPARATOR */              VSPACE_MULTIBYTE_CASES:
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4580  #endif  #endif
4581              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4582                default: break;
4583              }              }
4584            }            }
4585          break;          break;
# Line 4609  for (;;) Line 4595  for (;;)
4595            switch(*eptr++)            switch(*eptr++)
4596              {              {
4597              default: RRETURN(MATCH_NOMATCH);              default: RRETURN(MATCH_NOMATCH);
4598              case 0x0a:      /* LF */              VSPACE_BYTE_CASES:
             case 0x0b:      /* VT */  
             case 0x0c:      /* FF */  
             case 0x0d:      /* CR */  
             case 0x85:      /* NEL */  
4599  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
4600              case 0x2028:    /* LINE SEPARATOR */              VSPACE_MULTIBYTE_CASES:
             case 0x2029:    /* PARAGRAPH SEPARATOR */  
4601  #endif  #endif
4602              break;              break;
4603              }              }
# Line 4916  for (;;) Line 4897  for (;;)
4897              SCHECK_PARTIAL();              SCHECK_PARTIAL();
4898              RRETURN(MATCH_NOMATCH);              RRETURN(MATCH_NOMATCH);
4899              }              }
4900            GETCHARINCTEST(c, eptr);            else
           if (UCD_CATEGORY(c) == ucp_M) RRETURN(MATCH_NOMATCH);  
           while (eptr < md->end_subject)  
4901              {              {
4902              int len = 1;              int lgb, rgb;
4903              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
4904              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
4905              eptr += len;              while (eptr < md->end_subject)
4906                  {
4907                  int len = 1;
4908                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
4909                  rgb = UCD_GRAPHBREAK(c);
4910                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
4911                  lgb = rgb;
4912                  eptr += len;
4913                  }
4914              }              }
4915              CHECK_PARTIAL();
4916            }            }
4917          }          }
4918        else        else
# Line 4948  for (;;) Line 4936  for (;;)
4936            GETCHARINC(c, eptr);            GETCHARINC(c, eptr);
4937            switch(ctype)            switch(ctype)
4938              {              {
4939              case OP_ANY:        /* This is the non-NL case */              case OP_ANY:               /* This is the non-NL case */
4940                if (md->partial != 0 &&    /* Take care with CRLF partial */
4941                    eptr >= md->end_subject &&
4942                    NLBLOCK->nltype == NLTYPE_FIXED &&
4943                    NLBLOCK->nllen == 2 &&
4944                    c == NLBLOCK->nl[0])
4945                  {
4946                  md->hitend = TRUE;
4947                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
4948                  }
4949                break;
4950    
4951              case OP_ALLANY:              case OP_ALLANY:
4952              case OP_ANYBYTE:              case OP_ANYBYTE:
4953              break;              break;
# Line 4957  for (;;) Line 4956  for (;;)
4956              switch(c)              switch(c)
4957                {                {
4958                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
4959                case 0x000d:                case CHAR_CR:
4960                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
4961                break;                break;
4962                case 0x000a:  
4963                  case CHAR_LF:
4964                break;                break;
4965    
4966                case 0x000b:                case CHAR_VT:
4967                case 0x000c:                case CHAR_FF:
4968                case 0x0085:                case CHAR_NEL:
4969    #ifndef EBCDIC
4970                case 0x2028:                case 0x2028:
4971                case 0x2029:                case 0x2029:
4972    #endif  /* Not EBCDIC */
4973                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);                if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
4974                break;                break;
4975                }                }
# Line 4976  for (;;) Line 4978  for (;;)
4978              case OP_NOT_HSPACE:              case OP_NOT_HSPACE:
4979              switch(c)              switch(c)
4980                {                {
4981                  HSPACE_CASES: RRETURN(MATCH_NOMATCH);
4982                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);  
4983                }                }
4984              break;              break;
4985    
4986              case OP_HSPACE:              case OP_HSPACE:
4987              switch(c)              switch(c)
4988                {                {
4989                  HSPACE_CASES: break;
4990                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;  
4991                }                }
4992              break;              break;
4993    
4994              case OP_NOT_VSPACE:              case OP_NOT_VSPACE:
4995              switch(c)              switch(c)
4996                {                {
4997                  VSPACE_CASES: RRETURN(MATCH_NOMATCH);
4998                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);  
4999                }                }
5000              break;              break;
5001    
5002              case OP_VSPACE:              case OP_VSPACE:
5003              switch(c)              switch(c)
5004                {                {
5005                  VSPACE_CASES: break;
5006                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;  
5007                }                }
5008              break;              break;
5009    
# Line 5111  for (;;) Line 5061  for (;;)
5061            c = *eptr++;            c = *eptr++;
5062            switch(ctype)            switch(ctype)
5063              {              {
5064              case OP_ANY:     /* This is the non-NL case */              case OP_ANY:               /* This is the non-NL case */
5065                if (md->partial != 0 &&    /* Take care with CRLF partial */
5066                    eptr >= md->end_subject &&
5067                    NLBLOCK->nltype == NLTYPE_FIXED &&
5068                    NLBLOCK->nllen == 2 &&
5069                    c == NLBLOCK->nl[0])
5070                  {
5071                  md->hitend = TRUE;
5072                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5073                  }
5074                break;
5075    
5076              case OP_ALLANY:              case OP_ALLANY:
5077              case OP_ANYBYTE:              case OP_ANYBYTE:
5078              break;              break;
# Line 5120  for (;;) Line 5081  for (;;)
5081              switch(c)              switch(c)
5082                {                {
5083                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5084                case 0x000d:                case CHAR_CR:
5085                if (eptr < md->end_subject && *eptr == 0x0a) eptr++;                if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
5086                break;                break;
5087    
5088                case 0x000a:                case CHAR_LF:
5089                break;                break;
5090    
5091                case 0x000b:                case CHAR_VT:
5092                case 0x000c:                case CHAR_FF:
5093                case 0x0085:                case CHAR_NEL:
5094  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5095                case 0x2028:                case 0x2028:
5096                case 0x2029:                case 0x2029:
# Line 5143  for (;;) Line 5104  for (;;)
5104              switch(c)              switch(c)
5105                {                {
5106                default: break;                default: break;
5107                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
5108  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5109                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 */  
5110  #endif  #endif
5111                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5112                }                }
# Line 5172  for (;;) Line 5116  for (;;)
5116              switch(c)              switch(c)
5117                {                {
5118                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5119                case 0x09:      /* HT */                HSPACE_BYTE_CASES:
               case 0x20:      /* SPACE */  
               case 0xa0:      /* NBSP */  
5120  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5121                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 */  
5122  #endif  #endif
5123                break;                break;
5124                }                }
# Line 5201  for (;;) Line 5128  for (;;)
5128              switch(c)              switch(c)
5129                {                {
5130                default: break;                default: break;
5131                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
5132  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5133                case 0x2028:    /* LINE SEPARATOR */                VSPACE_MULTIBYTE_CASES:
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5134  #endif  #endif
5135                RRETURN(MATCH_NOMATCH);                RRETURN(MATCH_NOMATCH);
5136                }                }
# Line 5218  for (;;) Line 5140  for (;;)
5140              switch(c)              switch(c)
5141                {                {
5142                default: RRETURN(MATCH_NOMATCH);                default: RRETURN(MATCH_NOMATCH);
5143                case 0x0a:      /* LF */                VSPACE_BYTE_CASES:
               case 0x0b:      /* VT */  
               case 0x0c:      /* FF */  
               case 0x0d:      /* CR */  
               case 0x85:      /* NEL */  
5144  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5145                case 0x2028:    /* LINE SEPARATOR */                VSPACE_MULTIBYTE_CASES:
               case 0x2029:    /* PARAGRAPH SEPARATOR */  
5146  #endif  #endif
5147                break;                break;
5148                }                }
# Line 5452  for (;;) Line 5369  for (;;)
5369          {          {
5370          for (i = min; i < max; i++)          for (i = min; i < max; i++)
5371            {            {
           int len = 1;  
5372            if (eptr >= md->end_subject)            if (eptr >= md->end_subject)
5373              {              {
5374              SCHECK_PARTIAL();              SCHECK_PARTIAL();
5375              break;              break;
5376              }              }
5377            if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }            else
           if (UCD_CATEGORY(c) == ucp_M) break;  
           eptr += len;  
           while (eptr < md->end_subject)  
5378              {              {
5379              len = 1;              int lgb, rgb;
5380              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }              GETCHARINCTEST(c, eptr);
5381              if (UCD_CATEGORY(c) != ucp_M) break;              lgb = UCD_GRAPHBREAK(c);
5382              eptr += len;              while (eptr < md->end_subject)
5383                  {
5384                  int len = 1;
5385                  if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
5386                  rgb = UCD_GRAPHBREAK(c);
5387                  if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
5388                  lgb = rgb;
5389                  eptr += len;
5390                  }
5391              }              }
5392              CHECK_PARTIAL();
5393            }            }
5394    
5395          /* eptr is now past the end of the maximum run */          /* eptr is now past the end of the maximum run */
# Line 5511  for (;;) Line 5433  for (;;)
5433                  break;                  break;
5434                  }                  }
5435                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
5436                  if (md->partial != 0 &&    /* Take care with CRLF partial */
5437                      eptr + 1 >= md->end_subject &&
5438                      NLBLOCK->nltype == NLTYPE_FIXED &&
5439                      NLBLOCK->nllen == 2 &&
5440                      *eptr == NLBLOCK->nl[0])
5441                    {
5442                    md->hitend = TRUE;
5443                    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5444                    }
5445                eptr++;                eptr++;
5446                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5447                }                }
# Line 5528  for (;;) Line 5459  for (;;)
5459                  break;                  break;
5460                  }                  }
5461                if (IS_NEWLINE(eptr)) break;                if (IS_NEWLINE(eptr)) break;
5462                  if (md->partial != 0 &&    /* Take care with CRLF partial */
5463                      eptr + 1 >= md->end_subject &&
5464                      NLBLOCK->nltype == NLTYPE_FIXED &&
5465                      NLBLOCK->nllen == 2 &&
5466                      *eptr == NLBLOCK->nl[0])
5467                    {
5468                    md->hitend = TRUE;
5469                    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5470                    }
5471                eptr++;                eptr++;
5472                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);                ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
5473                }                }
# Line 5577  for (;;) Line 5517  for (;;)
5517                break;                break;
5518                }                }
5519              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5520              if (c == 0x000d)              if (c == CHAR_CR)
5521                {                {
5522                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5523                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5524                }                }
5525              else              else
5526                {                {
5527                if (c != 0x000a &&                if (c != CHAR_LF &&
5528                    (md->bsr_anycrlf ||                    (md->bsr_anycrlf ||
5529                     (c != 0x000b && c != 0x000c &&                     (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5530                      c != 0x0085 && c != 0x2028 && c != 0x2029)))  #ifndef EBCDIC
5531                        && c != 0x2028 && c != 0x2029
5532    #endif  /* Not EBCDIC */
5533                        )))
5534                  break;                  break;
5535                eptr += len;                eptr += len;
5536                }                }
# Line 5608  for (;;) Line 5551  for (;;)
5551              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5552              switch(c)              switch(c)
5553                {                {
5554                  HSPACE_CASES: gotspace = TRUE; break;
5555                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;  
5556                }                }
5557              if (gotspace == (ctype == OP_NOT_HSPACE)) break;              if (gotspace == (ctype == OP_NOT_HSPACE)) break;
5558              eptr += len;              eptr += len;
# Line 5650  for (;;) Line 5573  for (;;)
5573              GETCHARLEN(c, eptr, len);              GETCHARLEN(c, eptr, len);
5574              switch(c)              switch(c)
5575                {                {
5576                  VSPACE_CASES: gotspace = TRUE; break;
5577                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;  
5578                }                }
5579              if (gotspace == (ctype == OP_NOT_VSPACE)) break;              if (gotspace == (ctype == OP_NOT_VSPACE)) break;
5580              eptr += len;              eptr += len;
# Line 5773  for (;;) Line 5688  for (;;)
5688            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5689            if (eptr-- == pp) break;        /* Stop if tried at original pos */            if (eptr-- == pp) break;        /* Stop if tried at original pos */
5690            BACKCHAR(eptr);            BACKCHAR(eptr);
5691            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_NL &&
5692                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
5693            }            }
5694          }          }
5695        else        else
# Line 5792  for (;;) Line 5707  for (;;)
5707                break;                break;
5708                }                }
5709              if (IS_NEWLINE(eptr)) break;              if (IS_NEWLINE(eptr)) break;
5710                if (md->partial != 0 &&    /* Take care with CRLF partial */
5711                    eptr + 1 >= md->end_subject &&
5712                    NLBLOCK->nltype == NLTYPE_FIXED &&
5713                    NLBLOCK->nllen == 2 &&
5714                    *eptr == NLBLOCK->nl[0])
5715                  {
5716                  md->hitend = TRUE;
5717                  if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
5718                  }
5719              eptr++;              eptr++;
5720              }              }
5721            break;            break;
# Line 5816  for (;;) Line 5740  for (;;)
5740                break;                break;
5741                }                }
5742              c = *eptr;              c = *eptr;
5743              if (c == 0x000d)              if (c == CHAR_CR)
5744                {                {
5745                if (++eptr >= md->end_subject) break;                if (++eptr >= md->end_subject) break;
5746                if (*eptr == 0x000a) eptr++;                if (*eptr == CHAR_LF) eptr++;
5747                }                }
5748              else              else
5749                {                {
5750                if (c != 0x000a && (md->bsr_anycrlf ||                if (c != CHAR_LF && (md->bsr_anycrlf ||
5751                  (c != 0x000b && c != 0x000c && c != 0x0085                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
5752  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5753                  && c != 0x2028 && c != 0x2029                   && c != 0x2028 && c != 0x2029
5754  #endif  #endif
5755                  ))) break;                   ))) break;
5756                eptr++;                eptr++;
5757                }                }
5758              }              }
# Line 5842  for (;;) Line 5766  for (;;)
5766                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5767                break;                break;
5768                }                }
5769              c = *eptr;              switch(*eptr)
5770              if (c == 0x09 || c == 0x20 || c == 0xa0                {
5771                  default: eptr++; break;
5772                  HSPACE_BYTE_CASES:
5773  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5774                || c == 0x1680 || c == 0x180e || (c >= 0x2000 && c <= 0x200A)                HSPACE_MULTIBYTE_CASES:
               || c == 0x202f || c == 0x205f || c == 0x3000  
5775  #endif  #endif
5776                ) break;                goto ENDLOOP00;
5777              eptr++;                }
5778              }              }
5779              ENDLOOP00:
5780            break;            break;
5781    
5782            case OP_HSPACE:            case OP_HSPACE:
# Line 5861  for (;;) Line 5787  for (;;)
5787                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5788                break;                break;
5789                }                }
5790              c = *eptr;              switch(*eptr)
5791              if (c != 0x09 && c != 0x20 && c != 0xa0                {
5792                  default: goto ENDLOOP01;
5793                  HSPACE_BYTE_CASES:
5794  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5795                && c != 0x1680 && c != 0x180e && (c < 0x2000 || c > 0x200A)                HSPACE_MULTIBYTE_CASES:
               && c != 0x202f && c != 0x205f && c != 0x3000  
5796  #endif  #endif
5797                ) break;                eptr++; break;
5798              eptr++;                }
5799              }              }
5800              ENDLOOP01:
5801            break;            break;
5802    
5803            case OP_NOT_VSPACE:            case OP_NOT_VSPACE:
# Line 5880  for (;;) Line 5808  for (;;)
5808                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5809                break;                break;
5810                }                }
5811              c = *eptr;              switch(*eptr)
5812              if (c == 0x0a || c == 0x0b || c == 0x0c || c == 0x0d || c == 0x85                {
5813                  default: eptr++; break;
5814                  VSPACE_BYTE_CASES:
5815  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5816                || c == 0x2028 || c == 0x2029                VSPACE_MULTIBYTE_CASES:
5817  #endif  #endif
5818                ) break;                goto ENDLOOP02;
5819              eptr++;                }
5820              }              }
5821              ENDLOOP02:
5822            break;            break;
5823    
5824            case OP_VSPACE:            case OP_VSPACE:
# Line 5898  for (;;) Line 5829  for (;;)
5829                SCHECK_PARTIAL();                SCHECK_PARTIAL();
5830                break;                break;
5831                }                }
5832              c = *eptr;              switch(*eptr)
5833              if (c != 0x0a && c != 0x0b && c != 0x0c && c != 0x0d && c != 0x85                {
5834                  default: goto ENDLOOP03;
5835                  VSPACE_BYTE_CASES:
5836  #ifdef COMPILE_PCRE16  #ifdef COMPILE_PCRE16
5837                && c != 0x2028 && c != 0x2029                VSPACE_MULTIBYTE_CASES:
5838  #endif  #endif
5839                ) break;                eptr++; break;
5840              eptr++;                }
5841              }              }
5842              ENDLOOP03:
5843            break;            break;
5844    
5845            case OP_NOT_DIGIT:            case OP_NOT_DIGIT:
# Line 6002  for (;;) Line 5936  for (;;)
5936            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);            RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
5937            if (rrc != MATCH_NOMATCH) RRETURN(rrc);            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
5938            eptr--;            eptr--;
5939            if (ctype == OP_ANYNL && eptr > pp  && *eptr == '\n' &&            if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_LF &&
5940                eptr[-1] == '\r') eptr--;                eptr[-1] == CHAR_CR) eptr--;
5941            }            }
5942          }          }
5943    
# Line 6122  Undefine all the macros that were define Line 6056  Undefine all the macros that were define
6056  ***************************************************************************/  ***************************************************************************/
6057    
6058    
6059    #ifdef NO_RECURSE
6060    /*************************************************
6061    *          Release allocated heap frames         *
6062    *************************************************/
6063    
6064    /* This function releases all the allocated frames. The base frame is on the
6065    machine stack, and so must not be freed.
6066    
6067    Argument: the address of the base frame
6068    Returns:  nothing
6069    */
6070    
6071    static void
6072    release_match_heapframes (heapframe *frame_base)
6073    {
6074    heapframe *nextframe = frame_base->Xnextframe;
6075    while (nextframe != NULL)
6076      {
6077      heapframe *oldframe = nextframe;
6078      nextframe = nextframe->Xnextframe;
6079      (PUBL(stack_free))(oldframe);
6080      }
6081    }
6082    #endif
6083    
6084    
6085  /*************************************************  /*************************************************
6086  *         Execute a Regular Expression           *  *         Execute a Regular Expression           *
# Line 6184  PCRE_PUCHAR req_char_ptr = start_match - Line 6143  PCRE_PUCHAR req_char_ptr = start_match -
6143  const pcre_study_data *study;  const pcre_study_data *study;
6144  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;  const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
6145    
6146    #ifdef NO_RECURSE
6147    heapframe frame_zero;
6148    frame_zero.Xprevframe = NULL;            /* Marks the top level */
6149    frame_zero.Xnextframe = NULL;            /* None are allocated yet */
6150    md->match_frames_base = &frame_zero;
6151    #endif
6152    
6153    /* Check for the special magic call that measures the size of the stack used
6154    per recursive call of match(). Without the funny casting for sizeof, a Windows
6155    compiler gave this error: "unary minus operator applied to unsigned type,
6156    result still unsigned". Hopefully the cast fixes that. */
6157    
6158    if (re == NULL && extra_data == NULL && subject == NULL && length == -999 &&
6159        start_offset == -999)
6160    #ifdef NO_RECURSE
6161      return -((int)sizeof(heapframe));
6162    #else
6163      return match(NULL, NULL, NULL, 0, NULL, NULL, 0);
6164    #endif
6165    
6166  /* Plausibility checks */  /* Plausibility checks */
6167    
6168  if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;  if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
6169  if (re == NULL || subject == NULL ||  if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))
6170     (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;    return PCRE_ERROR_NULL;
6171  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;  if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
6172  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;  if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
6173    
6174    /* Check that the first field in the block is the magic number. If it is not,
6175    return with PCRE_ERROR_BADMAGIC. However, if the magic number is equal to
6176    REVERSED_MAGIC_NUMBER we return with PCRE_ERROR_BADENDIANNESS, which
6177    means that the pattern is likely compiled with different endianness. */
6178    
6179    if (re->magic_number != MAGIC_NUMBER)
6180      return re->magic_number == REVERSED_MAGIC_NUMBER?
6181        PCRE_ERROR_BADENDIANNESS:PCRE_ERROR_BADMAGIC;
6182    if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
6183    
6184  /* These two settings are used in the code for checking a UTF-8 string that  /* These two settings are used in the code for checking a UTF-8 string that
6185  follows immediately afterwards. Other values in the md block are used only  follows immediately afterwards. Other values in the md block are used only
6186  during "normal" pcre_exec() processing, not when the JIT support is in use,  during "normal" pcre_exec() processing, not when the JIT support is in use,
# Line 6236  if (utf && (options & PCRE_NO_UTF8_CHECK Line 6225  if (utf && (options & PCRE_NO_UTF8_CHECK
6225  /* If the pattern was successfully studied with JIT support, run the JIT  /* If the pattern was successfully studied with JIT support, run the JIT
6226  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
6227  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
6228  an unsupported flag is set. In particular, JIT does not support partial  an unsupported flag is set. */
 matching. */  
6229    
6230  #ifdef SUPPORT_JIT  #ifdef SUPPORT_JIT
6231  if (extra_data != NULL  if (extra_data != NULL
6232      && (extra_data->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0      && (extra_data->flags & (PCRE_EXTRA_EXECUTABLE_JIT |
6233                                 PCRE_EXTRA_TABLES)) == PCRE_EXTRA_EXECUTABLE_JIT
6234      && extra_data->executable_jit != NULL      && extra_data->executable_jit != NULL
     && (extra_data->flags & PCRE_EXTRA_TABLES) == 0  
6235      && (options & ~(PCRE_NO_UTF8_CHECK | PCRE_NOTBOL | PCRE_NOTEOL |      && (options & ~(PCRE_NO_UTF8_CHECK | PCRE_NOTBOL | PCRE_NOTEOL |
6236                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART)) == 0)                      PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART |
6237    return PRIV(jit_exec)(re, extra_data->executable_jit,                      PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD)) == 0)
6238      (const pcre_uchar *)subject, length, start_offset, options,    {
6239      ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0)    rc = PRIV(jit_exec)(re, extra_data, (const pcre_uchar *)subject, length,
6240      ? MATCH_LIMIT : extra_data->match_limit, offsets, offsetcount);         start_offset, options, offsets, offsetcount);
6241    
6242      /* PCRE_ERROR_NULL means that the selected normal or partial matching
6243      mode is not compiled. In this case we simply fallback to interpreter. */
6244    
6245      if (rc != PCRE_ERROR_NULL) return rc;
6246      }
6247  #endif  #endif
6248    
6249  /* 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 6291  in other programs later. */ Line 6285  in other programs later. */
6285    
6286  if (tables == NULL) tables = PRIV(default_tables);  if (tables == NULL) tables = PRIV(default_tables);
6287    
 /* Check that the first field in the block is the magic number. If it is not,  
 return with PCRE_ERROR_BADMAGIC. However, if the magic number is equal to  
 REVERSED_MAGIC_NUMBER we return with PCRE_ERROR_BADENDIANNESS, which  
 means that the pattern is likely compiled with different endianness. */  
   
 if (re->magic_number != MAGIC_NUMBER)  
   return re->magic_number == REVERSED_MAGIC_NUMBER?  
     PCRE_ERROR_BADENDIANNESS:PCRE_ERROR_BADMAGIC;  
 if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;  
   
6288  /* Set up other data */  /* Set up other data */
6289    
6290  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
# Line 6462  if (!anchored) Line 6446  if (!anchored)
6446    if ((re->flags & PCRE_FIRSTSET) != 0)    if ((re->flags & PCRE_FIRSTSET) != 0)
6447      {      {
6448      has_first_char = TRUE;      has_first_char = TRUE;
6449      first_char = first_char2 = re->first_char;      first_char = first_char2 = (pcre_uchar)(re->first_char);
6450      if ((re->flags & PCRE_FCH_CASELESS) != 0)      if ((re->flags & PCRE_FCH_CASELESS) != 0)
6451        {        {
6452        first_char2 = TABLE_GET(first_char, md->fcc, first_char);        first_char2 = TABLE_GET(first_char, md->fcc, first_char);
# Line 6484  character" set. */ Line 6468  character" set. */
6468  if ((re->flags & PCRE_REQCHSET) != 0)  if ((re->flags & PCRE_REQCHSET) != 0)
6469    {    {
6470    has_req_char = TRUE;    has_req_char = TRUE;
6471    req_char = req_char2 = re->req_char;    req_char = req_char2 = (pcre_uchar)(re->req_char);
6472    if ((re->flags & PCRE_RCH_CASELESS) != 0)    if ((re->flags & PCRE_RCH_CASELESS) != 0)
6473      {      {
6474      req_char2 = TABLE_GET(req_char, md->fcc, req_char);      req_char2 = TABLE_GET(req_char, md->fcc, req_char);
# Line 6853  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6837  if (rc == MATCH_MATCH || rc == MATCH_ACC
6837      {      {
6838      register int *iptr, *iend;      register int *iptr, *iend;
6839      int resetcount = 2 + re->top_bracket * 2;      int resetcount = 2 + re->top_bracket * 2;
6840      if (resetcount > offsetcount) resetcount = ocount;      if (resetcount > offsetcount) resetcount = offsetcount;
6841      iptr = offsets + md->end_offset_top;      iptr = offsets + md->end_offset_top;
6842      iend = offsets + resetcount;      iend = offsets + resetcount;
6843      while (iptr < iend) *iptr++ = -1;      while (iptr < iend) *iptr++ = -1;
# Line 6874  if (rc == MATCH_MATCH || rc == MATCH_ACC Line 6858  if (rc == MATCH_MATCH || rc == MATCH_ACC
6858    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)    if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6859      *(extra_data->mark) = (pcre_uchar *)md->mark;      *(extra_data->mark) = (pcre_uchar *)md->mark;
6860    DPRINTF((">>>> returning %d\n", rc));    DPRINTF((">>>> returning %d\n", rc));
6861    #ifdef NO_RECURSE
6862      release_match_heapframes(&frame_zero);
6863    #endif
6864    return rc;    return rc;
6865    }    }
6866    
# Line 6891  if (using_temporary_offsets) Line 6878  if (using_temporary_offsets)
6878  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)  if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
6879    {    {
6880    DPRINTF((">>>> error: returning %d\n", rc));    DPRINTF((">>>> error: returning %d\n", rc));
6881    #ifdef NO_RECURSE
6882      release_match_heapframes(&frame_zero);
6883    #endif
6884    return rc;    return rc;
6885    }    }
6886    
# Line 6920  else Line 6910  else
6910    
6911  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
6912    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;    *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;
6913    #ifdef NO_RECURSE
6914      release_match_heapframes(&frame_zero);
6915    #endif
6916  return rc;  return rc;
6917  }  }
6918    

Legend:
Removed from v.882  
changed lines
  Added in v.1041

  ViewVC Help
Powered by ViewVC 1.1.5