Parent Directory
| 
Revision Log
| 
Patch
| revision 427 by ph10, Fri Aug 28 09:55:54 2009 UTC | revision 530 by ph10, Tue Jun 1 13:42:06 2010 UTC | |
|---|---|---|
| # | Line 6 | Line 6 |
| 6 | and semantics are as close as possible to those of the Perl 5 language. | and semantics are as close as possible to those of the Perl 5 language. |
| 7 | ||
| 8 | Written by Philip Hazel | Written by Philip Hazel |
| 9 | Copyright (c) 1997-2009 University of Cambridge | Copyright (c) 1997-2010 University of Cambridge |
| 10 | ||
| 11 | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| 12 | Redistribution and use in source and binary forms, with or without | Redistribution and use in source and binary forms, with or without |
| # | Line 71 defined PCRE_ERROR_xxx codes, which are | Line 71 defined PCRE_ERROR_xxx codes, which are |
| 71 | /* Special internal returns from the match() function. Make them sufficiently | /* Special internal returns from the match() function. Make them sufficiently |
| 72 | negative to avoid the external error codes. */ | negative to avoid the external error codes. */ |
| 73 | ||
| 74 | #define MATCH_COMMIT (-999) | #define MATCH_ACCEPT (-999) |
| 75 | #define MATCH_PRUNE (-998) | #define MATCH_COMMIT (-998) |
| 76 | #define MATCH_SKIP (-997) | #define MATCH_PRUNE (-997) |
| 77 | #define MATCH_THEN (-996) | #define MATCH_SKIP (-996) |
| 78 | #define MATCH_SKIP_ARG (-995) | |
| 79 | #define MATCH_THEN (-994) | |
| 80 | ||
| 81 | /* This is a convenience macro for code that occurs many times. */ | |
| 82 | ||
| 83 | #define MRRETURN(ra) \ | |
| 84 | { \ | |
| 85 | md->mark = markptr; \ | |
| 86 | RRETURN(ra); \ | |
| 87 | } | |
| 88 | ||
| 89 | /* Maximum number of ints of offset to save on the stack for recursive calls. | /* Maximum number of ints of offset to save on the stack for recursive calls. |
| 90 | If the offset vector is bigger, malloc is used. This should be a multiple of 3, | If the offset vector is bigger, malloc is used. This should be a multiple of 3, |
| # | Line 89 static const char rep_max[] = { 0, 0, 0, | Line 99 static const char rep_max[] = { 0, 0, 0, |
| 99 | ||
| 100 | ||
| 101 | ||
| 102 | #ifdef DEBUG | #ifdef PCRE_DEBUG |
| 103 | /************************************************* | /************************************************* |
| 104 | * Debugging function to print chars * | * Debugging function to print chars * |
| 105 | *************************************************/ | *************************************************/ |
| # | Line 141 match_ref(int offset, register USPTR ept | Line 151 match_ref(int offset, register USPTR ept |
| 151 | { | { |
| 152 | USPTR p = md->start_subject + md->offset_vector[offset]; | USPTR p = md->start_subject + md->offset_vector[offset]; |
| 153 | ||
| 154 | #ifdef DEBUG | #ifdef PCRE_DEBUG |
| 155 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 156 | printf("matching subject <null>"); | printf("matching subject <null>"); |
| 157 | else | else |
| # | Line 245 enum { RM1=1, RM2, RM3, RM4, RM5, RM | Line 255 enum { RM1=1, RM2, RM3, RM4, RM5, RM |
| 255 | RM21, RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30, | RM21, RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30, |
| 256 | RM31, RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40, | RM31, RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40, |
| 257 | RM41, RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50, | RM41, RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50, |
| 258 | RM51, RM52, RM53, RM54 }; | RM51, RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60, |
| 259 | RM61, RM62 }; | |
| 260 | ||
| 261 | /* These versions of the macros use the stack, as normal. There are debugging | /* These versions of the macros use the stack, as normal. There are debugging |
| 262 | versions and production versions. Note that the "rw" argument of RMATCH isn't | versions and production versions. Note that the "rw" argument of RMATCH isn't |
| 263 | actuall used in this definition. */ | actually used in this definition. */ |
| 264 | ||
| 265 | #ifndef NO_RECURSE | #ifndef NO_RECURSE |
| 266 | #define REGISTER register | #define REGISTER register |
| 267 | ||
| 268 | #ifdef DEBUG | #ifdef PCRE_DEBUG |
| 269 | #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \ | #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \ |
| 270 | { \ | { \ |
| 271 | printf("match() called in line %d\n", __LINE__); \ | printf("match() called in line %d\n", __LINE__); \ |
| 272 | rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1); \ | rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1); \ |
| 273 | printf("to line %d\n", __LINE__); \ | printf("to line %d\n", __LINE__); \ |
| 274 | } | } |
| 275 | #define RRETURN(ra) \ | #define RRETURN(ra) \ |
| # | Line 268 actuall used in this definition. */ | Line 279 actuall used in this definition. */ |
| 279 | } | } |
| 280 | #else | #else |
| 281 | #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \ | #define RMATCH(ra,rb,rc,rd,re,rf,rg,rw) \ |
| 282 | rrc = match(ra,rb,mstart,rc,rd,re,rf,rg,rdepth+1) | rrc = match(ra,rb,mstart,markptr,rc,rd,re,rf,rg,rdepth+1) |
| 283 | #define RRETURN(ra) return ra | #define RRETURN(ra) return ra |
| 284 | #endif | #endif |
| 285 | ||
| # | Line 288 argument of match(), which never changes | Line 299 argument of match(), which never changes |
| 299 | newframe->Xeptr = ra;\ | newframe->Xeptr = ra;\ |
| 300 | newframe->Xecode = rb;\ | newframe->Xecode = rb;\ |
| 301 | newframe->Xmstart = mstart;\ | newframe->Xmstart = mstart;\ |
| 302 | newframe->Xmarkptr = markptr;\ | |
| 303 | newframe->Xoffset_top = rc;\ | newframe->Xoffset_top = rc;\ |
| 304 | newframe->Xims = re;\ | newframe->Xims = re;\ |
| 305 | newframe->Xeptrb = rf;\ | newframe->Xeptrb = rf;\ |
| # | Line 303 argument of match(), which never changes | Line 315 argument of match(), which never changes |
| 315 | ||
| 316 | #define RRETURN(ra)\ | #define RRETURN(ra)\ |
| 317 | {\ | {\ |
| 318 | heapframe *newframe = frame;\ | heapframe *oldframe = frame;\ |
| 319 | frame = newframe->Xprevframe;\ | frame = oldframe->Xprevframe;\ |
| 320 | (pcre_stack_free)(newframe);\ | (pcre_stack_free)(oldframe);\ |
| 321 | if (frame != NULL)\ | if (frame != NULL)\ |
| 322 | {\ | {\ |
| 323 | rrc = ra;\ | rrc = ra;\ |
| # | Line 325 typedef struct heapframe { | Line 337 typedef struct heapframe { |
| 337 | USPTR Xeptr; | USPTR Xeptr; |
| 338 | const uschar *Xecode; | const uschar *Xecode; |
| 339 | USPTR Xmstart; | USPTR Xmstart; |
| 340 | USPTR Xmarkptr; | |
| 341 | int Xoffset_top; | int Xoffset_top; |
| 342 | long int Xims; | long int Xims; |
| 343 | eptrblock *Xeptrb; | eptrblock *Xeptrb; |
| # | Line 408 immediately. The second one is used when | Line 421 immediately. The second one is used when |
| 421 | the subject. */ | the subject. */ |
| 422 | ||
| 423 | #define CHECK_PARTIAL()\ | #define CHECK_PARTIAL()\ |
| 424 | if (md->partial && eptr >= md->end_subject && eptr > mstart)\ | if (md->partial != 0 && eptr >= md->end_subject && eptr > mstart)\ |
| 425 | {\ | {\ |
| 426 | md->hitend = TRUE;\ | md->hitend = TRUE;\ |
| 427 | if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\ | if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\ |
| 428 | } | } |
| 429 | ||
| 430 | #define SCHECK_PARTIAL()\ | #define SCHECK_PARTIAL()\ |
| 431 | if (md->partial && eptr > mstart)\ | if (md->partial != 0 && eptr > mstart)\ |
| 432 | {\ | {\ |
| 433 | md->hitend = TRUE;\ | md->hitend = TRUE;\ |
| 434 | md->hitend = TRUE;\ | if (md->partial > 1) MRRETURN(PCRE_ERROR_PARTIAL);\ |
| if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);\ | ||
| 435 | } | } |
| 436 | ||
| 437 | ||
| # | Line 433 Arguments: | Line 445 Arguments: |
| 445 | ecode pointer to current position in compiled code | ecode pointer to current position in compiled code |
| 446 | mstart pointer to the current match start position (can be modified | mstart pointer to the current match start position (can be modified |
| 447 | by encountering \K) | by encountering \K) |
| 448 | markptr pointer to the most recent MARK name, or NULL | |
| 449 | offset_top current top pointer | offset_top current top pointer |
| 450 | md pointer to "static" info for the match | md pointer to "static" info for the match |
| 451 | ims current /i, /m, and /s options | ims current /i, /m, and /s options |
| # | Line 446 Arguments: | Line 459 Arguments: |
| 459 | ||
| 460 | Returns: MATCH_MATCH if matched ) these values are >= 0 | Returns: MATCH_MATCH if matched ) these values are >= 0 |
| 461 | MATCH_NOMATCH if failed to match ) | MATCH_NOMATCH if failed to match ) |
| 462 | a negative MATCH_xxx value for PRUNE, SKIP, etc | |
| 463 | a negative PCRE_ERROR_xxx value if aborted by an error condition | a negative PCRE_ERROR_xxx value if aborted by an error condition |
| 464 | (e.g. stopped by repeated call or recursion limit) | (e.g. stopped by repeated call or recursion limit) |
| 465 | */ | */ |
| 466 | ||
| 467 | static int | static int |
| 468 | match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart, | match(REGISTER USPTR eptr, REGISTER const uschar *ecode, USPTR mstart, |
| 469 | int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb, | const uschar *markptr, int offset_top, match_data *md, unsigned long int ims, |
| 470 | int flags, unsigned int rdepth) | eptrblock *eptrb, int flags, unsigned int rdepth) |
| 471 | { | { |
| 472 | /* These variables do not need to be preserved over recursion in this function, | /* These variables do not need to be preserved over recursion in this function, |
| 473 | so they can be ordinary variables in all cases. Mark some of them with | so they can be ordinary variables in all cases. Mark some of them with |
| # | Line 481 frame->Xprevframe = NULL; /* | Line 495 frame->Xprevframe = NULL; /* |
| 495 | frame->Xeptr = eptr; | frame->Xeptr = eptr; |
| 496 | frame->Xecode = ecode; | frame->Xecode = ecode; |
| 497 | frame->Xmstart = mstart; | frame->Xmstart = mstart; |
| 498 | frame->Xmarkptr = markptr; | |
| 499 | frame->Xoffset_top = offset_top; | frame->Xoffset_top = offset_top; |
| 500 | frame->Xims = ims; | frame->Xims = ims; |
| 501 | frame->Xeptrb = eptrb; | frame->Xeptrb = eptrb; |
| # | Line 496 HEAP_RECURSE: | Line 511 HEAP_RECURSE: |
| 511 | #define eptr frame->Xeptr | #define eptr frame->Xeptr |
| 512 | #define ecode frame->Xecode | #define ecode frame->Xecode |
| 513 | #define mstart frame->Xmstart | #define mstart frame->Xmstart |
| 514 | #define markptr frame->Xmarkptr | |
| 515 | #define offset_top frame->Xoffset_top | #define offset_top frame->Xoffset_top |
| 516 | #define ims frame->Xims | #define ims frame->Xims |
| 517 | #define eptrb frame->Xeptrb | #define eptrb frame->Xeptrb |
| # | Line 623 TAIL_RECURSE: | Line 639 TAIL_RECURSE: |
| 639 | /* OK, now we can get on with the real code of the function. Recursive calls | /* OK, now we can get on with the real code of the function. Recursive calls |
| 640 | are specified by the macro RMATCH and RRETURN is used to return. When | are specified by the macro RMATCH and RRETURN is used to return. When |
| 641 | NO_RECURSE is *not* defined, these just turn into a recursive call to match() | NO_RECURSE is *not* defined, these just turn into a recursive call to match() |
| 642 | and a "return", respectively (possibly with some debugging if DEBUG is | and a "return", respectively (possibly with some debugging if PCRE_DEBUG is |
| 643 | defined). However, RMATCH isn't like a function call because it's quite a | defined). However, RMATCH isn't like a function call because it's quite a |
| 644 | complicated macro. It has to be used in one particular way. This shouldn't, | complicated macro. It has to be used in one particular way. This shouldn't, |
| 645 | however, impact performance when true recursion is being used. */ | however, impact performance when true recursion is being used. */ |
| # | Line 665 for (;;) | Line 681 for (;;) |
| 681 | minimize = possessive = FALSE; | minimize = possessive = FALSE; |
| 682 | op = *ecode; | op = *ecode; |
| 683 | ||
| /* For partial matching, remember if we ever hit the end of the subject after | ||
| matching at least one subject character. This code is now wrapped in a macro | ||
| because it appears several times below. */ | ||
| CHECK_PARTIAL(); | ||
| 684 | switch(op) | switch(op) |
| 685 | { | { |
| 686 | case OP_MARK: | |
| 687 | markptr = ecode + 2; | |
| 688 | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md, | |
| 689 | ims, eptrb, flags, RM55); | |
| 690 | ||
| 691 | /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an | |
| 692 | argument, and we must check whether that argument matches this MARK's | |
| 693 | argument. It is passed back in md->start_match_ptr (an overloading of that | |
| 694 | variable). If it does match, we reset that variable to the current subject | |
| 695 | position and return MATCH_SKIP. Otherwise, pass back the return code | |
| 696 | unaltered. */ | |
| 697 | ||
| 698 | if (rrc == MATCH_SKIP_ARG && | |
| 699 | strcmp((char *)markptr, (char *)(md->start_match_ptr)) == 0) | |
| 700 | { | |
| 701 | md->start_match_ptr = eptr; | |
| 702 | RRETURN(MATCH_SKIP); | |
| 703 | } | |
| 704 | ||
| 705 | if (md->mark == NULL) md->mark = markptr; | |
| 706 | RRETURN(rrc); | |
| 707 | ||
| 708 | case OP_FAIL: | case OP_FAIL: |
| 709 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 710 | ||
| 711 | case OP_COMMIT: | |
| 712 | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, | |
| 713 | ims, eptrb, flags, RM52); | |
| 714 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | |
| 715 | MRRETURN(MATCH_COMMIT); | |
| 716 | ||
| 717 | case OP_PRUNE: | case OP_PRUNE: |
| 718 | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, |
| 719 | ims, eptrb, flags, RM51); | ims, eptrb, flags, RM51); |
| 720 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 721 | RRETURN(MATCH_PRUNE); | MRRETURN(MATCH_PRUNE); |
| 722 | ||
| 723 | case OP_COMMIT: | case OP_PRUNE_ARG: |
| 724 | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md, |
| 725 | ims, eptrb, flags, RM52); | ims, eptrb, flags, RM56); |
| 726 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 727 | RRETURN(MATCH_COMMIT); | md->mark = ecode + 2; |
| 728 | RRETURN(MATCH_PRUNE); | |
| 729 | ||
| 730 | case OP_SKIP: | case OP_SKIP: |
| 731 | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, |
| 732 | ims, eptrb, flags, RM53); | ims, eptrb, flags, RM53); |
| 733 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 734 | md->start_match_ptr = eptr; /* Pass back current position */ | md->start_match_ptr = eptr; /* Pass back current position */ |
| 735 | RRETURN(MATCH_SKIP); | MRRETURN(MATCH_SKIP); |
| 736 | ||
| 737 | case OP_SKIP_ARG: | |
| 738 | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md, | |
| 739 | ims, eptrb, flags, RM57); | |
| 740 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | |
| 741 | ||
| 742 | /* Pass back the current skip name by overloading md->start_match_ptr and | |
| 743 | returning the special MATCH_SKIP_ARG return code. This will either be | |
| 744 | caught by a matching MARK, or get to the top, where it is treated the same | |
| 745 | as PRUNE. */ | |
| 746 | ||
| 747 | md->start_match_ptr = ecode + 2; | |
| 748 | RRETURN(MATCH_SKIP_ARG); | |
| 749 | ||
| 750 | case OP_THEN: | case OP_THEN: |
| 751 | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, |
| 752 | ims, eptrb, flags, RM54); | ims, eptrb, flags, RM54); |
| 753 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 754 | MRRETURN(MATCH_THEN); | |
| 755 | ||
| 756 | case OP_THEN_ARG: | |
| 757 | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode] + ecode[1], offset_top, md, | |
| 758 | ims, eptrb, flags, RM58); | |
| 759 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | |
| 760 | md->mark = ecode + 2; | |
| 761 | RRETURN(MATCH_THEN); | RRETURN(MATCH_THEN); |
| 762 | ||
| 763 | /* Handle a capturing bracket. If there is space in the offset vector, save | /* Handle a capturing bracket. If there is space in the offset vector, save |
| # | Line 720 for (;;) | Line 779 for (;;) |
| 779 | number = GET2(ecode, 1+LINK_SIZE); | number = GET2(ecode, 1+LINK_SIZE); |
| 780 | offset = number << 1; | offset = number << 1; |
| 781 | ||
| 782 | #ifdef DEBUG | #ifdef PCRE_DEBUG |
| 783 | printf("start bracket %d\n", number); | printf("start bracket %d\n", number); |
| 784 | printf("subject="); | printf("subject="); |
| 785 | pchars(eptr, 16, TRUE, md); | pchars(eptr, 16, TRUE, md); |
| # | Line 735 for (;;) | Line 794 for (;;) |
| 794 | save_capture_last = md->capture_last; | save_capture_last = md->capture_last; |
| 795 | ||
| 796 | DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3)); | DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3)); |
| 797 | md->offset_vector[md->offset_end - number] = eptr - md->start_subject; | md->offset_vector[md->offset_end - number] = |
| 798 | (int)(eptr - md->start_subject); | |
| 799 | ||
| 800 | flags = (op == OP_SCBRA)? match_cbegroup : 0; | flags = (op == OP_SCBRA)? match_cbegroup : 0; |
| 801 | do | do |
| # | Line 754 for (;;) | Line 814 for (;;) |
| 814 | md->offset_vector[offset+1] = save_offset2; | md->offset_vector[offset+1] = save_offset2; |
| 815 | md->offset_vector[md->offset_end - number] = save_offset3; | md->offset_vector[md->offset_end - number] = save_offset3; |
| 816 | ||
| 817 | if (rrc != MATCH_THEN) md->mark = markptr; | |
| 818 | RRETURN(MATCH_NOMATCH); | RRETURN(MATCH_NOMATCH); |
| 819 | } | } |
| 820 | ||
| # | Line 793 for (;;) | Line 854 for (;;) |
| 854 | ||
| 855 | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims, | RMATCH(eptr, ecode + _pcre_OP_lengths[*ecode], offset_top, md, ims, |
| 856 | eptrb, flags, RM48); | eptrb, flags, RM48); |
| 857 | if (rrc == MATCH_NOMATCH) md->mark = markptr; | |
| 858 | RRETURN(rrc); | RRETURN(rrc); |
| 859 | } | } |
| 860 | ||
| # | Line 828 for (;;) | Line 890 for (;;) |
| 890 | cb.callout_number = ecode[LINK_SIZE+2]; | cb.callout_number = ecode[LINK_SIZE+2]; |
| 891 | cb.offset_vector = md->offset_vector; | cb.offset_vector = md->offset_vector; |
| 892 | cb.subject = (PCRE_SPTR)md->start_subject; | cb.subject = (PCRE_SPTR)md->start_subject; |
| 893 | cb.subject_length = md->end_subject - md->start_subject; | cb.subject_length = (int)(md->end_subject - md->start_subject); |
| 894 | cb.start_match = mstart - md->start_subject; | cb.start_match = (int)(mstart - md->start_subject); |
| 895 | cb.current_position = eptr - md->start_subject; | cb.current_position = (int)(eptr - md->start_subject); |
| 896 | cb.pattern_position = GET(ecode, LINK_SIZE + 3); | cb.pattern_position = GET(ecode, LINK_SIZE + 3); |
| 897 | cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE); | cb.next_item_length = GET(ecode, 3 + 2*LINK_SIZE); |
| 898 | cb.capture_top = offset_top/2; | cb.capture_top = offset_top/2; |
| 899 | cb.capture_last = md->capture_last; | cb.capture_last = md->capture_last; |
| 900 | cb.callout_data = md->callout_data; | cb.callout_data = md->callout_data; |
| 901 | if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH); | if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH); |
| 902 | if (rrc < 0) RRETURN(rrc); | if (rrc < 0) RRETURN(rrc); |
| 903 | } | } |
| 904 | ecode += _pcre_OP_lengths[OP_CALLOUT]; | ecode += _pcre_OP_lengths[OP_CALLOUT]; |
| # | Line 846 for (;;) | Line 908 for (;;) |
| 908 | ||
| 909 | /* Now see what the actual condition is */ | /* Now see what the actual condition is */ |
| 910 | ||
| 911 | if (condcode == OP_RREF) /* Recursion test */ | if (condcode == OP_RREF || condcode == OP_NRREF) /* Recursion test */ |
| 912 | { | { |
| 913 | offset = GET2(ecode, LINK_SIZE + 2); /* Recursion group number*/ | if (md->recursive == NULL) /* Not recursing => FALSE */ |
| 914 | condition = md->recursive != NULL && | { |
| 915 | (offset == RREF_ANY || offset == md->recursive->group_num); | condition = FALSE; |
| 916 | ecode += condition? 3 : GET(ecode, 1); | ecode += GET(ecode, 1); |
| 917 | } | |
| 918 | else | |
| 919 | { | |
| 920 | int recno = GET2(ecode, LINK_SIZE + 2); /* Recursion group number*/ | |
| 921 | condition = (recno == RREF_ANY || recno == md->recursive->group_num); | |
| 922 | ||
| 923 | /* If the test is for recursion into a specific subpattern, and it is | |
| 924 | false, but the test was set up by name, scan the table to see if the | |
| 925 | name refers to any other numbers, and test them. The condition is true | |
| 926 | if any one is set. */ | |
| 927 | ||
| 928 | if (!condition && condcode == OP_NRREF && recno != RREF_ANY) | |
| 929 | { | |
| 930 | uschar *slotA = md->name_table; | |
| 931 | for (i = 0; i < md->name_count; i++) | |
| 932 | { | |
| 933 | if (GET2(slotA, 0) == recno) break; | |
| 934 | slotA += md->name_entry_size; | |
| 935 | } | |
| 936 | ||
| 937 | /* Found a name for the number - there can be only one; duplicate | |
| 938 | names for different numbers are allowed, but not vice versa. First | |
| 939 | scan down for duplicates. */ | |
| 940 | ||
| 941 | if (i < md->name_count) | |
| 942 | { | |
| 943 | uschar *slotB = slotA; | |
| 944 | while (slotB > md->name_table) | |
| 945 | { | |
| 946 | slotB -= md->name_entry_size; | |
| 947 | if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0) | |
| 948 | { | |
| 949 | condition = GET2(slotB, 0) == md->recursive->group_num; | |
| 950 | if (condition) break; | |
| 951 | } | |
| 952 | else break; | |
| 953 | } | |
| 954 | ||
| 955 | /* Scan up for duplicates */ | |
| 956 | ||
| 957 | if (!condition) | |
| 958 | { | |
| 959 | slotB = slotA; | |
| 960 | for (i++; i < md->name_count; i++) | |
| 961 | { | |
| 962 | slotB += md->name_entry_size; | |
| 963 | if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0) | |
| 964 | { | |
| 965 | condition = GET2(slotB, 0) == md->recursive->group_num; | |
| 966 | if (condition) break; | |
| 967 | } | |
| 968 | else break; | |
| 969 | } | |
| 970 | } | |
| 971 | } | |
| 972 | } | |
| 973 | ||
| 974 | /* Chose branch according to the condition */ | |
| 975 | ||
| 976 | ecode += condition? 3 : GET(ecode, 1); | |
| 977 | } | |
| 978 | } | } |
| 979 | ||
| 980 | else if (condcode == OP_CREF) /* Group used test */ | else if (condcode == OP_CREF || condcode == OP_NCREF) /* Group used test */ |
| 981 | { | { |
| 982 | offset = GET2(ecode, LINK_SIZE+2) << 1; /* Doubled ref number */ | offset = GET2(ecode, LINK_SIZE+2) << 1; /* Doubled ref number */ |
| 983 | condition = offset < offset_top && md->offset_vector[offset] >= 0; | condition = offset < offset_top && md->offset_vector[offset] >= 0; |
| 984 | ||
| 985 | /* If the numbered capture is unset, but the reference was by name, | |
| 986 | scan the table to see if the name refers to any other numbers, and test | |
| 987 | them. The condition is true if any one is set. This is tediously similar | |
| 988 | to the code above, but not close enough to try to amalgamate. */ | |
| 989 | ||
| 990 | if (!condition && condcode == OP_NCREF) | |
| 991 | { | |
| 992 | int refno = offset >> 1; | |
| 993 | uschar *slotA = md->name_table; | |
| 994 | ||
| 995 | for (i = 0; i < md->name_count; i++) | |
| 996 | { | |
| 997 | if (GET2(slotA, 0) == refno) break; | |
| 998 | slotA += md->name_entry_size; | |
| 999 | } | |
| 1000 | ||
| 1001 | /* Found a name for the number - there can be only one; duplicate names | |
| 1002 | for different numbers are allowed, but not vice versa. First scan down | |
| 1003 | for duplicates. */ | |
| 1004 | ||
| 1005 | if (i < md->name_count) | |
| 1006 | { | |
| 1007 | uschar *slotB = slotA; | |
| 1008 | while (slotB > md->name_table) | |
| 1009 | { | |
| 1010 | slotB -= md->name_entry_size; | |
| 1011 | if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0) | |
| 1012 | { | |
| 1013 | offset = GET2(slotB, 0) << 1; | |
| 1014 | condition = offset < offset_top && | |
| 1015 | md->offset_vector[offset] >= 0; | |
| 1016 | if (condition) break; | |
| 1017 | } | |
| 1018 | else break; | |
| 1019 | } | |
| 1020 | ||
| 1021 | /* Scan up for duplicates */ | |
| 1022 | ||
| 1023 | if (!condition) | |
| 1024 | { | |
| 1025 | slotB = slotA; | |
| 1026 | for (i++; i < md->name_count; i++) | |
| 1027 | { | |
| 1028 | slotB += md->name_entry_size; | |
| 1029 | if (strcmp((char *)slotA + 2, (char *)slotB + 2) == 0) | |
| 1030 | { | |
| 1031 | offset = GET2(slotB, 0) << 1; | |
| 1032 | condition = offset < offset_top && | |
| 1033 | md->offset_vector[offset] >= 0; | |
| 1034 | if (condition) break; | |
| 1035 | } | |
| 1036 | else break; | |
| 1037 | } | |
| 1038 | } | |
| 1039 | } | |
| 1040 | } | |
| 1041 | ||
| 1042 | /* Chose branch according to the condition */ | |
| 1043 | ||
| 1044 | ecode += condition? 3 : GET(ecode, 1); | ecode += condition? 3 : GET(ecode, 1); |
| 1045 | } | } |
| 1046 | ||
| # | Line 918 for (;;) | Line 1101 for (;;) |
| 1101 | break; | break; |
| 1102 | ||
| 1103 | ||
| 1104 | /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes, | |
| 1105 | to close any currently open capturing brackets. */ | |
| 1106 | ||
| 1107 | case OP_CLOSE: | |
| 1108 | number = GET2(ecode, 1); | |
| 1109 | offset = number << 1; | |
| 1110 | ||
| 1111 | #ifdef PCRE_DEBUG | |
| 1112 | printf("end bracket %d at *ACCEPT", number); | |
| 1113 | printf("\n"); | |
| 1114 | #endif | |
| 1115 | ||
| 1116 | md->capture_last = number; | |
| 1117 | if (offset >= md->offset_max) md->offset_overflow = TRUE; else | |
| 1118 | { | |
| 1119 | md->offset_vector[offset] = | |
| 1120 | md->offset_vector[md->offset_end - number]; | |
| 1121 | md->offset_vector[offset+1] = (int)(eptr - md->start_subject); | |
| 1122 | if (offset_top <= offset) offset_top = offset + 2; | |
| 1123 | } | |
| 1124 | ecode += 3; | |
| 1125 | break; | |
| 1126 | ||
| 1127 | ||
| 1128 | /* End of the pattern, either real or forced. If we are in a top-level | /* End of the pattern, either real or forced. If we are in a top-level |
| 1129 | recursion, we should restore the offsets appropriately and continue from | recursion, we should restore the offsets appropriately and continue from |
| 1130 | after the call. */ | after the call. */ |
| # | Line 931 for (;;) | Line 1138 for (;;) |
| 1138 | md->recursive = rec->prevrec; | md->recursive = rec->prevrec; |
| 1139 | memmove(md->offset_vector, rec->offset_save, | memmove(md->offset_vector, rec->offset_save, |
| 1140 | rec->saved_max * sizeof(int)); | rec->saved_max * sizeof(int)); |
| 1141 | mstart = rec->save_start; | offset_top = rec->save_offset_top; |
| 1142 | ims = original_ims; | ims = original_ims; |
| 1143 | ecode = rec->after_call; | ecode = rec->after_call; |
| 1144 | break; | break; |
| 1145 | } | } |
| 1146 | ||
| 1147 | /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty | /* Otherwise, if we have matched an empty string, fail if PCRE_NOTEMPTY is |
| 1148 | string - backtracking will then try other alternatives, if any. */ | set, or if PCRE_NOTEMPTY_ATSTART is set and we have matched at the start of |
| 1149 | the subject. In both cases, backtracking will then try other alternatives, | |
| 1150 | if any. */ | |
| 1151 | ||
| 1152 | if (eptr == mstart && | |
| 1153 | (md->notempty || | |
| 1154 | (md->notempty_atstart && | |
| 1155 | mstart == md->start_subject + md->start_offset))) | |
| 1156 | MRRETURN(MATCH_NOMATCH); | |
| 1157 | ||
| 1158 | /* Otherwise, we have a match. */ | |
| 1159 | ||
| if (md->notempty && eptr == mstart) RRETURN(MATCH_NOMATCH); | ||
| 1160 | md->end_match_ptr = eptr; /* Record where we ended */ | md->end_match_ptr = eptr; /* Record where we ended */ |
| 1161 | md->end_offset_top = offset_top; /* and how many extracts were taken */ | md->end_offset_top = offset_top; /* and how many extracts were taken */ |
| 1162 | md->start_match_ptr = mstart; /* and the start (\K can modify) */ | md->start_match_ptr = mstart; /* and the start (\K can modify) */ |
| 1163 | RRETURN(MATCH_MATCH); | |
| 1164 | /* For some reason, the macros don't work properly if an expression is | |
| 1165 | given as the argument to MRRETURN when the heap is in use. */ | |
| 1166 | ||
| 1167 | rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT; | |
| 1168 | MRRETURN(rrc); | |
| 1169 | ||
| 1170 | /* Change option settings */ | /* Change option settings */ |
| 1171 | ||
| # | Line 966 for (;;) | Line 1187 for (;;) |
| 1187 | { | { |
| 1188 | RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0, | RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0, |
| 1189 | RM4); | RM4); |
| 1190 | if (rrc == MATCH_MATCH) break; | if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) |
| 1191 | { | |
| 1192 | mstart = md->start_match_ptr; /* In case \K reset it */ | |
| 1193 | break; | |
| 1194 | } | |
| 1195 | if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc); | if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc); |
| 1196 | ecode += GET(ecode, 1); | ecode += GET(ecode, 1); |
| 1197 | } | } |
| 1198 | while (*ecode == OP_ALT); | while (*ecode == OP_ALT); |
| 1199 | if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH); | if (*ecode == OP_KET) MRRETURN(MATCH_NOMATCH); |
| 1200 | ||
| 1201 | /* If checking an assertion for a condition, return MATCH_MATCH. */ | /* If checking an assertion for a condition, return MATCH_MATCH. */ |
| 1202 | ||
| # | Line 985 for (;;) | Line 1210 for (;;) |
| 1210 | offset_top = md->end_offset_top; | offset_top = md->end_offset_top; |
| 1211 | continue; | continue; |
| 1212 | ||
| 1213 | /* Negative assertion: all branches must fail to match */ | /* Negative assertion: all branches must fail to match. Encountering SKIP, |
| 1214 | PRUNE, or COMMIT means we must assume failure without checking subsequent | |
| 1215 | branches. */ | |
| 1216 | ||
| 1217 | case OP_ASSERT_NOT: | case OP_ASSERT_NOT: |
| 1218 | case OP_ASSERTBACK_NOT: | case OP_ASSERTBACK_NOT: |
| # | Line 993 for (;;) | Line 1220 for (;;) |
| 1220 | { | { |
| 1221 | RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0, | RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL, 0, |
| 1222 | RM5); | RM5); |
| 1223 | if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH); | if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) MRRETURN(MATCH_NOMATCH); |
| 1224 | if (rrc == MATCH_SKIP || rrc == MATCH_PRUNE || rrc == MATCH_COMMIT) | |
| 1225 | { | |
| 1226 | do ecode += GET(ecode,1); while (*ecode == OP_ALT); | |
| 1227 | break; | |
| 1228 | } | |
| 1229 | if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc); | if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc); |
| 1230 | ecode += GET(ecode,1); | ecode += GET(ecode,1); |
| 1231 | } | } |
| # | Line 1017 for (;;) | Line 1249 for (;;) |
| 1249 | while (i-- > 0) | while (i-- > 0) |
| 1250 | { | { |
| 1251 | eptr--; | eptr--; |
| 1252 | if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH); | if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH); |
| 1253 | BACKCHAR(eptr); | BACKCHAR(eptr); |
| 1254 | } | } |
| 1255 | } | } |
| # | Line 1028 for (;;) | Line 1260 for (;;) |
| 1260 | ||
| 1261 | { | { |
| 1262 | eptr -= GET(ecode, 1); | eptr -= GET(ecode, 1); |
| 1263 | if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH); | if (eptr < md->start_subject) MRRETURN(MATCH_NOMATCH); |
| 1264 | } | } |
| 1265 | ||
| 1266 | /* Skip to next op code */ | /* Save the earliest consulted character, then skip to next op code */ |
| 1267 | ||
| 1268 | if (eptr < md->start_used_ptr) md->start_used_ptr = eptr; | |
| 1269 | ecode += 1 + LINK_SIZE; | ecode += 1 + LINK_SIZE; |
| 1270 | break; | break; |
| 1271 | ||
| # | Line 1048 for (;;) | Line 1281 for (;;) |
| 1281 | cb.callout_number = ecode[1]; | cb.callout_number = ecode[1]; |
| 1282 | cb.offset_vector = md->offset_vector; | cb.offset_vector = md->offset_vector; |
| 1283 | cb.subject = (PCRE_SPTR)md->start_subject; | cb.subject = (PCRE_SPTR)md->start_subject; |
| 1284 | cb.subject_length = md->end_subject - md->start_subject; | cb.subject_length = (int)(md->end_subject - md->start_subject); |
| 1285 | cb.start_match = mstart - md->start_subject; | cb.start_match = (int)(mstart - md->start_subject); |
| 1286 | cb.current_position = eptr - md->start_subject; | cb.current_position = (int)(eptr - md->start_subject); |
| 1287 | cb.pattern_position = GET(ecode, 2); | cb.pattern_position = GET(ecode, 2); |
| 1288 | cb.next_item_length = GET(ecode, 2 + LINK_SIZE); | cb.next_item_length = GET(ecode, 2 + LINK_SIZE); |
| 1289 | cb.capture_top = offset_top/2; | cb.capture_top = offset_top/2; |
| 1290 | cb.capture_last = md->capture_last; | cb.capture_last = md->capture_last; |
| 1291 | cb.callout_data = md->callout_data; | cb.callout_data = md->callout_data; |
| 1292 | if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH); | if ((rrc = (*pcre_callout)(&cb)) > 0) MRRETURN(MATCH_NOMATCH); |
| 1293 | if (rrc < 0) RRETURN(rrc); | if (rrc < 0) RRETURN(rrc); |
| 1294 | } | } |
| 1295 | ecode += 2 + 2*LINK_SIZE; | ecode += 2 + 2*LINK_SIZE; |
| # | Line 1111 for (;;) | Line 1344 for (;;) |
| 1344 | ||
| 1345 | memcpy(new_recursive.offset_save, md->offset_vector, | memcpy(new_recursive.offset_save, md->offset_vector, |
| 1346 | new_recursive.saved_max * sizeof(int)); | new_recursive.saved_max * sizeof(int)); |
| 1347 | new_recursive.save_start = mstart; | new_recursive.save_offset_top = offset_top; |
| mstart = eptr; | ||
| 1348 | ||
| 1349 | /* OK, now we can do the recursion. For each top-level alternative we | /* OK, now we can do the recursion. For each top-level alternative we |
| 1350 | restore the offset and recursion data. */ | restore the offset and recursion data. */ |
| # | Line 1123 for (;;) | Line 1355 for (;;) |
| 1355 | { | { |
| 1356 | RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top, | RMATCH(eptr, callpat + _pcre_OP_lengths[*callpat], offset_top, |
| 1357 | md, ims, eptrb, flags, RM6); | md, ims, eptrb, flags, RM6); |
| 1358 | if (rrc == MATCH_MATCH) | if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) |
| 1359 | { | { |
| 1360 | DPRINTF(("Recursion matched\n")); | DPRINTF(("Recursion matched\n")); |
| 1361 | md->recursive = new_recursive.prevrec; | md->recursive = new_recursive.prevrec; |
| 1362 | if (new_recursive.offset_save != stacksave) | if (new_recursive.offset_save != stacksave) |
| 1363 | (pcre_free)(new_recursive.offset_save); | (pcre_free)(new_recursive.offset_save); |
| 1364 | RRETURN(MATCH_MATCH); | MRRETURN(MATCH_MATCH); |
| 1365 | } | } |
| 1366 | else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) | else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) |
| 1367 | { | { |
| # | Line 1150 for (;;) | Line 1382 for (;;) |
| 1382 | md->recursive = new_recursive.prevrec; | md->recursive = new_recursive.prevrec; |
| 1383 | if (new_recursive.offset_save != stacksave) | if (new_recursive.offset_save != stacksave) |
| 1384 | (pcre_free)(new_recursive.offset_save); | (pcre_free)(new_recursive.offset_save); |
| 1385 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1386 | } | } |
| 1387 | /* Control never reaches here */ | /* Control never reaches here */ |
| 1388 | ||
| # | Line 1159 for (;;) | Line 1391 for (;;) |
| 1391 | a move back into the brackets. Friedl calls these "atomic" subpatterns. | a move back into the brackets. Friedl calls these "atomic" subpatterns. |
| 1392 | Check the alternative branches in turn - the matching won't pass the KET | Check the alternative branches in turn - the matching won't pass the KET |
| 1393 | for this kind of subpattern. If any one branch matches, we carry on as at | for this kind of subpattern. If any one branch matches, we carry on as at |
| 1394 | the end of a normal bracket, leaving the subject pointer. */ | the end of a normal bracket, leaving the subject pointer, but resetting |
| 1395 | the start-of-match value in case it was changed by \K. */ | |
| 1396 | ||
| 1397 | case OP_ONCE: | case OP_ONCE: |
| 1398 | prev = ecode; | prev = ecode; |
| # | Line 1168 for (;;) | Line 1401 for (;;) |
| 1401 | do | do |
| 1402 | { | { |
| 1403 | RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7); | RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0, RM7); |
| 1404 | if (rrc == MATCH_MATCH) break; | if (rrc == MATCH_MATCH) /* Note: _not_ MATCH_ACCEPT */ |
| 1405 | { | |
| 1406 | mstart = md->start_match_ptr; | |
| 1407 | break; | |
| 1408 | } | |
| 1409 | if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc); | if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN) RRETURN(rrc); |
| 1410 | ecode += GET(ecode,1); | ecode += GET(ecode,1); |
| 1411 | } | } |
| # | Line 1287 for (;;) | Line 1524 for (;;) |
| 1524 | } | } |
| 1525 | else saved_eptr = NULL; | else saved_eptr = NULL; |
| 1526 | ||
| 1527 | /* If we are at the end of an assertion group, stop matching and return | /* If we are at the end of an assertion group or an atomic group, stop |
| 1528 | MATCH_MATCH, but record the current high water mark for use by positive | matching and return MATCH_MATCH, but record the current high water mark for |
| 1529 | assertions. Do this also for the "once" (atomic) groups. */ | use by positive assertions. We also need to record the match start in case |
| 1530 | it was changed by \K. */ | |
| 1531 | ||
| 1532 | if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT || | if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT || |
| 1533 | *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT || | *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT || |
| # | Line 1297 for (;;) | Line 1535 for (;;) |
| 1535 | { | { |
| 1536 | md->end_match_ptr = eptr; /* For ONCE */ | md->end_match_ptr = eptr; /* For ONCE */ |
| 1537 | md->end_offset_top = offset_top; | md->end_offset_top = offset_top; |
| 1538 | RRETURN(MATCH_MATCH); | md->start_match_ptr = mstart; |
| 1539 | MRRETURN(MATCH_MATCH); | |
| 1540 | } | } |
| 1541 | ||
| 1542 | /* For capturing groups we have to check the group number back at the start | /* For capturing groups we have to check the group number back at the start |
| # | Line 1311 for (;;) | Line 1550 for (;;) |
| 1550 | number = GET2(prev, 1+LINK_SIZE); | number = GET2(prev, 1+LINK_SIZE); |
| 1551 | offset = number << 1; | offset = number << 1; |
| 1552 | ||
| 1553 | #ifdef DEBUG | #ifdef PCRE_DEBUG |
| 1554 | printf("end bracket %d", number); | printf("end bracket %d", number); |
| 1555 | printf("\n"); | printf("\n"); |
| 1556 | #endif | #endif |
| # | Line 1321 for (;;) | Line 1560 for (;;) |
| 1560 | { | { |
| 1561 | md->offset_vector[offset] = | md->offset_vector[offset] = |
| 1562 | md->offset_vector[md->offset_end - number]; | md->offset_vector[md->offset_end - number]; |
| 1563 | md->offset_vector[offset+1] = eptr - md->start_subject; | md->offset_vector[offset+1] = (int)(eptr - md->start_subject); |
| 1564 | if (offset_top <= offset) offset_top = offset + 2; | if (offset_top <= offset) offset_top = offset + 2; |
| 1565 | } | } |
| 1566 | ||
| # | Line 1333 for (;;) | Line 1572 for (;;) |
| 1572 | recursion_info *rec = md->recursive; | recursion_info *rec = md->recursive; |
| 1573 | DPRINTF(("Recursion (%d) succeeded - continuing\n", number)); | DPRINTF(("Recursion (%d) succeeded - continuing\n", number)); |
| 1574 | md->recursive = rec->prevrec; | md->recursive = rec->prevrec; |
| mstart = rec->save_start; | ||
| 1575 | memcpy(md->offset_vector, rec->offset_save, | memcpy(md->offset_vector, rec->offset_save, |
| 1576 | rec->saved_max * sizeof(int)); | rec->saved_max * sizeof(int)); |
| 1577 | offset_top = rec->save_offset_top; | |
| 1578 | ecode = rec->after_call; | ecode = rec->after_call; |
| 1579 | ims = original_ims; | ims = original_ims; |
| 1580 | break; | break; |
| # | Line 1392 for (;;) | Line 1631 for (;;) |
| 1631 | /* Start of subject unless notbol, or after internal newline if multiline */ | /* Start of subject unless notbol, or after internal newline if multiline */ |
| 1632 | ||
| 1633 | case OP_CIRC: | case OP_CIRC: |
| 1634 | if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH); | if (md->notbol && eptr == md->start_subject) MRRETURN(MATCH_NOMATCH); |
| 1635 | if ((ims & PCRE_MULTILINE) != 0) | if ((ims & PCRE_MULTILINE) != 0) |
| 1636 | { | { |
| 1637 | if (eptr != md->start_subject && | if (eptr != md->start_subject && |
| 1638 | (eptr == md->end_subject || !WAS_NEWLINE(eptr))) | (eptr == md->end_subject || !WAS_NEWLINE(eptr))) |
| 1639 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1640 | ecode++; | ecode++; |
| 1641 | break; | break; |
| 1642 | } | } |
| # | Line 1406 for (;;) | Line 1645 for (;;) |
| 1645 | /* Start of subject assertion */ | /* Start of subject assertion */ |
| 1646 | ||
| 1647 | case OP_SOD: | case OP_SOD: |
| 1648 | if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH); | if (eptr != md->start_subject) MRRETURN(MATCH_NOMATCH); |
| 1649 | ecode++; | ecode++; |
| 1650 | break; | break; |
| 1651 | ||
| 1652 | /* Start of match assertion */ | /* Start of match assertion */ |
| 1653 | ||
| 1654 | case OP_SOM: | case OP_SOM: |
| 1655 | if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH); | if (eptr != md->start_subject + md->start_offset) MRRETURN(MATCH_NOMATCH); |
| 1656 | ecode++; | ecode++; |
| 1657 | break; | break; |
| 1658 | ||
| # | Line 1431 for (;;) | Line 1670 for (;;) |
| 1670 | if ((ims & PCRE_MULTILINE) != 0) | if ((ims & PCRE_MULTILINE) != 0) |
| 1671 | { | { |
| 1672 | if (eptr < md->end_subject) | if (eptr < md->end_subject) |
| 1673 | { if (!IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); } | { if (!IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); } |
| 1674 | else | else |
| 1675 | { if (md->noteol) RRETURN(MATCH_NOMATCH); } | { if (md->noteol) MRRETURN(MATCH_NOMATCH); } |
| 1676 | ecode++; | ecode++; |
| 1677 | break; | break; |
| 1678 | } | } |
| 1679 | else | else |
| 1680 | { | { |
| 1681 | if (md->noteol) RRETURN(MATCH_NOMATCH); | if (md->noteol) MRRETURN(MATCH_NOMATCH); |
| 1682 | if (!md->endonly) | if (!md->endonly) |
| 1683 | { | { |
| 1684 | if (eptr != md->end_subject && | if (eptr != md->end_subject && |
| 1685 | (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen)) | (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen)) |
| 1686 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1687 | ecode++; | ecode++; |
| 1688 | break; | break; |
| 1689 | } | } |
| # | Line 1454 for (;;) | Line 1693 for (;;) |
| 1693 | /* End of subject assertion (\z) */ | /* End of subject assertion (\z) */ |
| 1694 | ||
| 1695 | case OP_EOD: | case OP_EOD: |
| 1696 | if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr < md->end_subject) MRRETURN(MATCH_NOMATCH); |
| 1697 | ecode++; | ecode++; |
| 1698 | break; | break; |
| 1699 | ||
| # | Line 1463 for (;;) | Line 1702 for (;;) |
| 1702 | case OP_EODN: | case OP_EODN: |
| 1703 | if (eptr != md->end_subject && | if (eptr != md->end_subject && |
| 1704 | (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen)) | (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen)) |
| 1705 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1706 | ecode++; | ecode++; |
| 1707 | break; | break; |
| 1708 | ||
| # | Line 1475 for (;;) | Line 1714 for (;;) |
| 1714 | ||
| 1715 | /* Find out if the previous and current characters are "word" characters. | /* Find out if the previous and current characters are "word" characters. |
| 1716 | It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to | It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to |
| 1717 | be "non-word" characters. */ | be "non-word" characters. Remember the earliest consulted character for |
| 1718 | partial matching. */ | |
| 1719 | ||
| 1720 | #ifdef SUPPORT_UTF8 | #ifdef SUPPORT_UTF8 |
| 1721 | if (utf8) | if (utf8) |
| 1722 | { | { |
| 1723 | /* Get status of previous character */ | |
| 1724 | ||
| 1725 | if (eptr == md->start_subject) prev_is_word = FALSE; else | if (eptr == md->start_subject) prev_is_word = FALSE; else |
| 1726 | { | { |
| 1727 | USPTR lastptr = eptr - 1; | USPTR lastptr = eptr - 1; |
| 1728 | while((*lastptr & 0xc0) == 0x80) lastptr--; | while((*lastptr & 0xc0) == 0x80) lastptr--; |
| 1729 | if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr; | |
| 1730 | GETCHAR(c, lastptr); | GETCHAR(c, lastptr); |
| 1731 | #ifdef SUPPORT_UCP | |
| 1732 | if (md->use_ucp) | |
| 1733 | { | |
| 1734 | if (c == '_') prev_is_word = TRUE; else | |
| 1735 | { | |
| 1736 | int cat = UCD_CATEGORY(c); | |
| 1737 | prev_is_word = (cat == ucp_L || cat == ucp_N); | |
| 1738 | } | |
| 1739 | } | |
| 1740 | else | |
| 1741 | #endif | |
| 1742 | prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0; | prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0; |
| 1743 | } | } |
| 1744 | if (eptr >= md->end_subject) cur_is_word = FALSE; else | |
| 1745 | /* Get status of next character */ | |
| 1746 | ||
| 1747 | if (eptr >= md->end_subject) | |
| 1748 | { | |
| 1749 | SCHECK_PARTIAL(); | |
| 1750 | cur_is_word = FALSE; | |
| 1751 | } | |
| 1752 | else | |
| 1753 | { | { |
| 1754 | GETCHAR(c, eptr); | GETCHAR(c, eptr); |
| 1755 | #ifdef SUPPORT_UCP | |
| 1756 | if (md->use_ucp) | |
| 1757 | { | |
| 1758 | if (c == '_') cur_is_word = TRUE; else | |
| 1759 | { | |
| 1760 | int cat = UCD_CATEGORY(c); | |
| 1761 | cur_is_word = (cat == ucp_L || cat == ucp_N); | |
| 1762 | } | |
| 1763 | } | |
| 1764 | else | |
| 1765 | #endif | |
| 1766 | cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0; | cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0; |
| 1767 | } | } |
| 1768 | } | } |
| 1769 | else | else |
| 1770 | #endif | #endif |
| 1771 | ||
| 1772 | /* More streamlined when not in UTF-8 mode */ | /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for |
| 1773 | consistency with the behaviour of \w we do use it in this case. */ | |
| 1774 | ||
| 1775 | { | { |
| 1776 | prev_is_word = (eptr != md->start_subject) && | /* Get status of previous character */ |
| 1777 | ((md->ctypes[eptr[-1]] & ctype_word) != 0); | |
| 1778 | cur_is_word = (eptr < md->end_subject) && | if (eptr == md->start_subject) prev_is_word = FALSE; else |
| 1779 | ((md->ctypes[*eptr] & ctype_word) != 0); | { |
| 1780 | if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1; | |
| 1781 | #ifdef SUPPORT_UCP | |
| 1782 | if (md->use_ucp) | |
| 1783 | { | |
| 1784 | c = eptr[-1]; | |
| 1785 | if (c == '_') prev_is_word = TRUE; else | |
| 1786 | { | |
| 1787 | int cat = UCD_CATEGORY(c); | |
| 1788 | prev_is_word = (cat == ucp_L || cat == ucp_N); | |
| 1789 | } | |
| 1790 | } | |
| 1791 | else | |
| 1792 | #endif | |
| 1793 | prev_is_word = ((md->ctypes[eptr[-1]] & ctype_word) != 0); | |
| 1794 | } | |
| 1795 | ||
| 1796 | /* Get status of next character */ | |
| 1797 | ||
| 1798 | if (eptr >= md->end_subject) | |
| 1799 | { | |
| 1800 | SCHECK_PARTIAL(); | |
| 1801 | cur_is_word = FALSE; | |
| 1802 | } | |
| 1803 | else | |
| 1804 | #ifdef SUPPORT_UCP | |
| 1805 | if (md->use_ucp) | |
| 1806 | { | |
| 1807 | c = *eptr; | |
| 1808 | if (c == '_') cur_is_word = TRUE; else | |
| 1809 | { | |
| 1810 | int cat = UCD_CATEGORY(c); | |
| 1811 | cur_is_word = (cat == ucp_L || cat == ucp_N); | |
| 1812 | } | |
| 1813 | } | |
| 1814 | else | |
| 1815 | #endif | |
| 1816 | cur_is_word = ((md->ctypes[*eptr] & ctype_word) != 0); | |
| 1817 | } | } |
| 1818 | ||
| 1819 | /* Now see if the situation is what we want */ | /* Now see if the situation is what we want */ |
| 1820 | ||
| 1821 | if ((*ecode++ == OP_WORD_BOUNDARY)? | if ((*ecode++ == OP_WORD_BOUNDARY)? |
| 1822 | cur_is_word == prev_is_word : cur_is_word != prev_is_word) | cur_is_word == prev_is_word : cur_is_word != prev_is_word) |
| 1823 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1824 | } | } |
| 1825 | break; | break; |
| 1826 | ||
| 1827 | /* Match a single character type; inline for speed */ | /* Match a single character type; inline for speed */ |
| 1828 | ||
| 1829 | case OP_ANY: | case OP_ANY: |
| 1830 | if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); | if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); |
| 1831 | /* Fall through */ | /* Fall through */ |
| 1832 | ||
| 1833 | case OP_ALLANY: | case OP_ALLANY: |
| 1834 | if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr++ >= md->end_subject) |
| 1835 | { | |
| 1836 | SCHECK_PARTIAL(); | |
| 1837 | MRRETURN(MATCH_NOMATCH); | |
| 1838 | } | |
| 1839 | if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; | if (utf8) while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; |
| 1840 | ecode++; | ecode++; |
| 1841 | break; | break; |
| # | Line 1529 for (;;) | Line 1844 for (;;) |
| 1844 | any byte, even newline, independent of the setting of PCRE_DOTALL. */ | any byte, even newline, independent of the setting of PCRE_DOTALL. */ |
| 1845 | ||
| 1846 | case OP_ANYBYTE: | case OP_ANYBYTE: |
| 1847 | if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr++ >= md->end_subject) |
| 1848 | { | |
| 1849 | SCHECK_PARTIAL(); | |
| 1850 | MRRETURN(MATCH_NOMATCH); | |
| 1851 | } | |
| 1852 | ecode++; | ecode++; |
| 1853 | break; | break; |
| 1854 | ||
| 1855 | case OP_NOT_DIGIT: | case OP_NOT_DIGIT: |
| 1856 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 1857 | { | |
| 1858 | SCHECK_PARTIAL(); | |
| 1859 | MRRETURN(MATCH_NOMATCH); | |
| 1860 | } | |
| 1861 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 1862 | if ( | if ( |
| 1863 | #ifdef SUPPORT_UTF8 | #ifdef SUPPORT_UTF8 |
| # | Line 1542 for (;;) | Line 1865 for (;;) |
| 1865 | #endif | #endif |
| 1866 | (md->ctypes[c] & ctype_digit) != 0 | (md->ctypes[c] & ctype_digit) != 0 |
| 1867 | ) | ) |
| 1868 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1869 | ecode++; | ecode++; |
| 1870 | break; | break; |
| 1871 | ||
| 1872 | case OP_DIGIT: | case OP_DIGIT: |
| 1873 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 1874 | { | |
| 1875 | SCHECK_PARTIAL(); | |
| 1876 | MRRETURN(MATCH_NOMATCH); | |
| 1877 | } | |
| 1878 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 1879 | if ( | if ( |
| 1880 | #ifdef SUPPORT_UTF8 | #ifdef SUPPORT_UTF8 |
| # | Line 1555 for (;;) | Line 1882 for (;;) |
| 1882 | #endif | #endif |
| 1883 | (md->ctypes[c] & ctype_digit) == 0 | (md->ctypes[c] & ctype_digit) == 0 |
| 1884 | ) | ) |
| 1885 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1886 | ecode++; | ecode++; |
| 1887 | break; | break; |
| 1888 | ||
| 1889 | case OP_NOT_WHITESPACE: | case OP_NOT_WHITESPACE: |
| 1890 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 1891 | { | |
| 1892 | SCHECK_PARTIAL(); | |
| 1893 | MRRETURN(MATCH_NOMATCH); | |
| 1894 | } | |
| 1895 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 1896 | if ( | if ( |
| 1897 | #ifdef SUPPORT_UTF8 | #ifdef SUPPORT_UTF8 |
| # | Line 1568 for (;;) | Line 1899 for (;;) |
| 1899 | #endif | #endif |
| 1900 | (md->ctypes[c] & ctype_space) != 0 | (md->ctypes[c] & ctype_space) != 0 |
| 1901 | ) | ) |
| 1902 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1903 | ecode++; | ecode++; |
| 1904 | break; | break; |
| 1905 | ||
| 1906 | case OP_WHITESPACE: | case OP_WHITESPACE: |
| 1907 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 1908 | { | |
| 1909 | SCHECK_PARTIAL(); | |
| 1910 | MRRETURN(MATCH_NOMATCH); | |
| 1911 | } | |
| 1912 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 1913 | if ( | if ( |
| 1914 | #ifdef SUPPORT_UTF8 | #ifdef SUPPORT_UTF8 |
| # | Line 1581 for (;;) | Line 1916 for (;;) |
| 1916 | #endif | #endif |
| 1917 | (md->ctypes[c] & ctype_space) == 0 | (md->ctypes[c] & ctype_space) == 0 |
| 1918 | ) | ) |
| 1919 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1920 | ecode++; | ecode++; |
| 1921 | break; | break; |
| 1922 | ||
| 1923 | case OP_NOT_WORDCHAR: | case OP_NOT_WORDCHAR: |
| 1924 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 1925 | { | |
| 1926 | SCHECK_PARTIAL(); | |
| 1927 | MRRETURN(MATCH_NOMATCH); | |
| 1928 | } | |
| 1929 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 1930 | if ( | if ( |
| 1931 | #ifdef SUPPORT_UTF8 | #ifdef SUPPORT_UTF8 |
| # | Line 1594 for (;;) | Line 1933 for (;;) |
| 1933 | #endif | #endif |
| 1934 | (md->ctypes[c] & ctype_word) != 0 | (md->ctypes[c] & ctype_word) != 0 |
| 1935 | ) | ) |
| 1936 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1937 | ecode++; | ecode++; |
| 1938 | break; | break; |
| 1939 | ||
| 1940 | case OP_WORDCHAR: | case OP_WORDCHAR: |
| 1941 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 1942 | { | |
| 1943 | SCHECK_PARTIAL(); | |
| 1944 | MRRETURN(MATCH_NOMATCH); | |
| 1945 | } | |
| 1946 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 1947 | if ( | if ( |
| 1948 | #ifdef SUPPORT_UTF8 | #ifdef SUPPORT_UTF8 |
| # | Line 1607 for (;;) | Line 1950 for (;;) |
| 1950 | #endif | #endif |
| 1951 | (md->ctypes[c] & ctype_word) == 0 | (md->ctypes[c] & ctype_word) == 0 |
| 1952 | ) | ) |
| 1953 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 1954 | ecode++; | ecode++; |
| 1955 | break; | break; |
| 1956 | ||
| 1957 | case OP_ANYNL: | case OP_ANYNL: |
| 1958 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 1959 | { | |
| 1960 | SCHECK_PARTIAL(); | |
| 1961 | MRRETURN(MATCH_NOMATCH); | |
| 1962 | } | |
| 1963 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 1964 | switch(c) | switch(c) |
| 1965 | { | { |
| 1966 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 1967 | case 0x000d: | case 0x000d: |
| 1968 | if (eptr < md->end_subject && *eptr == 0x0a) eptr++; | if (eptr < md->end_subject && *eptr == 0x0a) eptr++; |
| 1969 | break; | break; |
| # | Line 1629 for (;;) | Line 1976 for (;;) |
| 1976 | case 0x0085: | case 0x0085: |
| 1977 | case 0x2028: | case 0x2028: |
| 1978 | case 0x2029: | case 0x2029: |
| 1979 | if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH); | if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH); |
| 1980 | break; | break; |
| 1981 | } | } |
| 1982 | ecode++; | ecode++; |
| 1983 | break; | break; |
| 1984 | ||
| 1985 | case OP_NOT_HSPACE: | case OP_NOT_HSPACE: |
| 1986 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 1987 | { | |
| 1988 | SCHECK_PARTIAL(); | |
| 1989 | MRRETURN(MATCH_NOMATCH); | |
| 1990 | } | |
| 1991 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 1992 | switch(c) | switch(c) |
| 1993 | { | { |
| # | Line 1660 for (;;) | Line 2011 for (;;) |
| 2011 | case 0x202f: /* NARROW NO-BREAK SPACE */ | case 0x202f: /* NARROW NO-BREAK SPACE */ |
| 2012 | case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ | case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ |
| 2013 | case 0x3000: /* IDEOGRAPHIC SPACE */ | case 0x3000: /* IDEOGRAPHIC SPACE */ |
| 2014 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2015 | } | } |
| 2016 | ecode++; | ecode++; |
| 2017 | break; | break; |
| 2018 | ||
| 2019 | case OP_HSPACE: | case OP_HSPACE: |
| 2020 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 2021 | { | |
| 2022 | SCHECK_PARTIAL(); | |
| 2023 | MRRETURN(MATCH_NOMATCH); | |
| 2024 | } | |
| 2025 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 2026 | switch(c) | switch(c) |
| 2027 | { | { |
| 2028 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 2029 | case 0x09: /* HT */ | case 0x09: /* HT */ |
| 2030 | case 0x20: /* SPACE */ | case 0x20: /* SPACE */ |
| 2031 | case 0xa0: /* NBSP */ | case 0xa0: /* NBSP */ |
| # | Line 1696 for (;;) | Line 2051 for (;;) |
| 2051 | break; | break; |
| 2052 | ||
| 2053 | case OP_NOT_VSPACE: | case OP_NOT_VSPACE: |
| 2054 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 2055 | { | |
| 2056 | SCHECK_PARTIAL(); | |
| 2057 | MRRETURN(MATCH_NOMATCH); | |
| 2058 | } | |
| 2059 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 2060 | switch(c) | switch(c) |
| 2061 | { | { |
| # | Line 1708 for (;;) | Line 2067 for (;;) |
| 2067 | case 0x85: /* NEL */ | case 0x85: /* NEL */ |
| 2068 | case 0x2028: /* LINE SEPARATOR */ | case 0x2028: /* LINE SEPARATOR */ |
| 2069 | case 0x2029: /* PARAGRAPH SEPARATOR */ | case 0x2029: /* PARAGRAPH SEPARATOR */ |
| 2070 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2071 | } | } |
| 2072 | ecode++; | ecode++; |
| 2073 | break; | break; |
| 2074 | ||
| 2075 | case OP_VSPACE: | case OP_VSPACE: |
| 2076 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 2077 | { | |
| 2078 | SCHECK_PARTIAL(); | |
| 2079 | MRRETURN(MATCH_NOMATCH); | |
| 2080 | } | |
| 2081 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 2082 | switch(c) | switch(c) |
| 2083 | { | { |
| 2084 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 2085 | case 0x0a: /* LF */ | case 0x0a: /* LF */ |
| 2086 | case 0x0b: /* VT */ | case 0x0b: /* VT */ |
| 2087 | case 0x0c: /* FF */ | case 0x0c: /* FF */ |
| # | Line 1737 for (;;) | Line 2100 for (;;) |
| 2100 | ||
| 2101 | case OP_PROP: | case OP_PROP: |
| 2102 | case OP_NOTPROP: | case OP_NOTPROP: |
| 2103 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 2104 | { | |
| 2105 | SCHECK_PARTIAL(); | |
| 2106 | MRRETURN(MATCH_NOMATCH); | |
| 2107 | } | |
| 2108 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 2109 | { | { |
| 2110 | const ucd_record *prop = GET_UCD(c); | const ucd_record *prop = GET_UCD(c); |
| # | Line 1745 for (;;) | Line 2112 for (;;) |
| 2112 | switch(ecode[1]) | switch(ecode[1]) |
| 2113 | { | { |
| 2114 | case PT_ANY: | case PT_ANY: |
| 2115 | if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH); | if (op == OP_NOTPROP) MRRETURN(MATCH_NOMATCH); |
| 2116 | break; | break; |
| 2117 | ||
| 2118 | case PT_LAMP: | case PT_LAMP: |
| 2119 | if ((prop->chartype == ucp_Lu || | if ((prop->chartype == ucp_Lu || |
| 2120 | prop->chartype == ucp_Ll || | prop->chartype == ucp_Ll || |
| 2121 | prop->chartype == ucp_Lt) == (op == OP_NOTPROP)) | prop->chartype == ucp_Lt) == (op == OP_NOTPROP)) |
| 2122 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2123 | break; | break; |
| 2124 | ||
| 2125 | case PT_GC: | case PT_GC: |
| 2126 | if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP)) | if ((ecode[2] != _pcre_ucp_gentype[prop->chartype]) == (op == OP_PROP)) |
| 2127 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2128 | break; | break; |
| 2129 | ||
| 2130 | case PT_PC: | case PT_PC: |
| 2131 | if ((ecode[2] != prop->chartype) == (op == OP_PROP)) | if ((ecode[2] != prop->chartype) == (op == OP_PROP)) |
| 2132 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2133 | break; | break; |
| 2134 | ||
| 2135 | case PT_SC: | case PT_SC: |
| 2136 | if ((ecode[2] != prop->script) == (op == OP_PROP)) | if ((ecode[2] != prop->script) == (op == OP_PROP)) |
| 2137 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2138 | break; | |
| 2139 | ||
| 2140 | /* These are specials */ | |
| 2141 | ||
| 2142 | case PT_ALNUM: | |
| 2143 | if ((_pcre_ucp_gentype[prop->chartype] == ucp_L || | |
| 2144 | _pcre_ucp_gentype[prop->chartype] == ucp_N) == (op == OP_NOTPROP)) | |
| 2145 | MRRETURN(MATCH_NOMATCH); | |
| 2146 | break; | |
| 2147 | ||
| 2148 | case PT_SPACE: /* Perl space */ | |
| 2149 | if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z || | |
| 2150 | c == CHAR_HT || c == CHAR_NL || c == CHAR_FF || c == CHAR_CR) | |
| 2151 | == (op == OP_NOTPROP)) | |
| 2152 | MRRETURN(MATCH_NOMATCH); | |
| 2153 | break; | break; |
| 2154 | ||
| 2155 | case PT_PXSPACE: /* POSIX space */ | |
| 2156 | if ((_pcre_ucp_gentype[prop->chartype] == ucp_Z || | |
| 2157 | c == CHAR_HT || c == CHAR_NL || c == CHAR_VT || | |
| 2158 | c == CHAR_FF || c == CHAR_CR) | |
| 2159 | == (op == OP_NOTPROP)) | |
| 2160 | MRRETURN(MATCH_NOMATCH); | |
| 2161 | break; | |
| 2162 | ||
| 2163 | case PT_WORD: | |
| 2164 | if ((_pcre_ucp_gentype[prop->chartype] == ucp_L || | |
| 2165 | _pcre_ucp_gentype[prop->chartype] == ucp_N || | |
| 2166 | c == CHAR_UNDERSCORE) == (op == OP_NOTPROP)) | |
| 2167 | MRRETURN(MATCH_NOMATCH); | |
| 2168 | break; | |
| 2169 | ||
| 2170 | /* This should never occur */ | |
| 2171 | ||
| 2172 | default: | default: |
| 2173 | RRETURN(PCRE_ERROR_INTERNAL); | RRETURN(PCRE_ERROR_INTERNAL); |
| 2174 | } | } |
| # | Line 1782 for (;;) | Line 2181 for (;;) |
| 2181 | is in the binary; otherwise a compile-time error occurs. */ | is in the binary; otherwise a compile-time error occurs. */ |
| 2182 | ||
| 2183 | case OP_EXTUNI: | case OP_EXTUNI: |
| 2184 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 2185 | { | |
| 2186 | SCHECK_PARTIAL(); | |
| 2187 | MRRETURN(MATCH_NOMATCH); | |
| 2188 | } | |
| 2189 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 2190 | { | { |
| 2191 | int category = UCD_CATEGORY(c); | int category = UCD_CATEGORY(c); |
| 2192 | if (category == ucp_M) RRETURN(MATCH_NOMATCH); | if (category == ucp_M) MRRETURN(MATCH_NOMATCH); |
| 2193 | while (eptr < md->end_subject) | while (eptr < md->end_subject) |
| 2194 | { | { |
| 2195 | int len = 1; | int len = 1; |
| # | Line 1831 for (;;) | Line 2234 for (;;) |
| 2234 | referenced subpattern. */ | referenced subpattern. */ |
| 2235 | ||
| 2236 | if (offset >= offset_top || md->offset_vector[offset] < 0) | if (offset >= offset_top || md->offset_vector[offset] < 0) |
| 2237 | length = (md->jscript_compat)? 0 : md->end_subject - eptr + 1; | length = (md->jscript_compat)? 0 : (int)(md->end_subject - eptr + 1); |
| 2238 | else | else |
| 2239 | length = md->offset_vector[offset+1] - md->offset_vector[offset]; | length = md->offset_vector[offset+1] - md->offset_vector[offset]; |
| 2240 | ||
| # | Line 1862 for (;;) | Line 2265 for (;;) |
| 2265 | break; | break; |
| 2266 | ||
| 2267 | default: /* No repeat follows */ | default: /* No repeat follows */ |
| 2268 | if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH); | if (!match_ref(offset, eptr, length, md, ims)) |
| 2269 | { | |
| 2270 | CHECK_PARTIAL(); | |
| 2271 | MRRETURN(MATCH_NOMATCH); | |
| 2272 | } | |
| 2273 | eptr += length; | eptr += length; |
| 2274 | continue; /* With the main loop */ | continue; /* With the main loop */ |
| 2275 | } | } |
| # | Line 1881 for (;;) | Line 2288 for (;;) |
| 2288 | if (!match_ref(offset, eptr, length, md, ims)) | if (!match_ref(offset, eptr, length, md, ims)) |
| 2289 | { | { |
| 2290 | CHECK_PARTIAL(); | CHECK_PARTIAL(); |
| 2291 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2292 | } | } |
| 2293 | eptr += length; | eptr += length; |
| 2294 | } | } |
| # | Line 1899 for (;;) | Line 2306 for (;;) |
| 2306 | { | { |
| 2307 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM14); |
| 2308 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 2309 | if (fi >= max || !match_ref(offset, eptr, length, md, ims)) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| 2310 | if (!match_ref(offset, eptr, length, md, ims)) | |
| 2311 | { | { |
| 2312 | CHECK_PARTIAL(); | CHECK_PARTIAL(); |
| 2313 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2314 | } | } |
| 2315 | eptr += length; | eptr += length; |
| 2316 | } | } |
| # | Line 1916 for (;;) | Line 2324 for (;;) |
| 2324 | pp = eptr; | pp = eptr; |
| 2325 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 2326 | { | { |
| 2327 | if (!match_ref(offset, eptr, length, md, ims)) break; | if (!match_ref(offset, eptr, length, md, ims)) |
| 2328 | { | |
| 2329 | CHECK_PARTIAL(); | |
| 2330 | break; | |
| 2331 | } | |
| 2332 | eptr += length; | eptr += length; |
| 2333 | } | } |
| CHECK_PARTIAL(); | ||
| 2334 | while (eptr >= pp) | while (eptr >= pp) |
| 2335 | { | { |
| 2336 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM15); |
| 2337 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 2338 | eptr -= length; | eptr -= length; |
| 2339 | } | } |
| 2340 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2341 | } | } |
| 2342 | } | } |
| 2343 | /* Control never gets here */ | /* Control never gets here */ |
| 2344 | ||
| 2345 | /* Match a bit-mapped character class, possibly repeatedly. This op code is | /* Match a bit-mapped character class, possibly repeatedly. This op code is |
| 2346 | used when all the characters in the class have values in the range 0-255, | used when all the characters in the class have values in the range 0-255, |
| 2347 | and either the matching is caseful, or the characters are in the range | and either the matching is caseful, or the characters are in the range |
| # | Line 1989 for (;;) | Line 2398 for (;;) |
| 2398 | { | { |
| 2399 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 2400 | { | { |
| 2401 | CHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 2402 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2403 | } | } |
| 2404 | GETCHARINC(c, eptr); | GETCHARINC(c, eptr); |
| 2405 | if (c > 255) | if (c > 255) |
| 2406 | { | { |
| 2407 | if (op == OP_CLASS) RRETURN(MATCH_NOMATCH); | if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH); |
| 2408 | } | } |
| 2409 | else | else |
| 2410 | { | { |
| 2411 | if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH); | if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH); |
| 2412 | } | } |
| 2413 | } | } |
| 2414 | } | } |
| # | Line 2011 for (;;) | Line 2420 for (;;) |
| 2420 | { | { |
| 2421 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 2422 | { | { |
| 2423 | CHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 2424 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2425 | } | } |
| 2426 | c = *eptr++; | c = *eptr++; |
| 2427 | if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH); | if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH); |
| 2428 | } | } |
| 2429 | } | } |
| 2430 | ||
| # | Line 2037 for (;;) | Line 2446 for (;;) |
| 2446 | { | { |
| 2447 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM16); |
| 2448 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 2449 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 2450 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 2451 | { | { |
| 2452 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 2453 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2454 | } | } |
| 2455 | GETCHARINC(c, eptr); | GETCHARINC(c, eptr); |
| 2456 | if (c > 255) | if (c > 255) |
| 2457 | { | { |
| 2458 | if (op == OP_CLASS) RRETURN(MATCH_NOMATCH); | if (op == OP_CLASS) MRRETURN(MATCH_NOMATCH); |
| 2459 | } | } |
| 2460 | else | else |
| 2461 | { | { |
| 2462 | if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH); | if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH); |
| 2463 | } | } |
| 2464 | } | } |
| 2465 | } | } |
| # | Line 2066 for (;;) | Line 2471 for (;;) |
| 2471 | { | { |
| 2472 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM17); |
| 2473 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 2474 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 2475 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 2476 | { | { |
| 2477 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 2478 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2479 | } | } |
| 2480 | c = *eptr++; | c = *eptr++; |
| 2481 | if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH); | if ((data[c/8] & (1 << (c&7))) == 0) MRRETURN(MATCH_NOMATCH); |
| 2482 | } | } |
| 2483 | } | } |
| 2484 | /* Control never gets here */ | /* Control never gets here */ |
| # | Line 2096 for (;;) | Line 2497 for (;;) |
| 2497 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 2498 | { | { |
| 2499 | int len = 1; | int len = 1; |
| 2500 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 2501 | { | |
| 2502 | SCHECK_PARTIAL(); | |
| 2503 | break; | |
| 2504 | } | |
| 2505 | GETCHARLEN(c, eptr, len); | GETCHARLEN(c, eptr, len); |
| 2506 | if (c > 255) | if (c > 255) |
| 2507 | { | { |
| # | Line 2108 for (;;) | Line 2513 for (;;) |
| 2513 | } | } |
| 2514 | eptr += len; | eptr += len; |
| 2515 | } | } |
| CHECK_PARTIAL(); | ||
| 2516 | for (;;) | for (;;) |
| 2517 | { | { |
| 2518 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM18); |
| # | Line 2123 for (;;) | Line 2527 for (;;) |
| 2527 | { | { |
| 2528 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 2529 | { | { |
| 2530 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 2531 | { | |
| 2532 | SCHECK_PARTIAL(); | |
| 2533 | break; | |
| 2534 | } | |
| 2535 | c = *eptr; | c = *eptr; |
| 2536 | if ((data[c/8] & (1 << (c&7))) == 0) break; | if ((data[c/8] & (1 << (c&7))) == 0) break; |
| 2537 | eptr++; | eptr++; |
| 2538 | } | } |
| CHECK_PARTIAL(); | ||
| 2539 | while (eptr >= pp) | while (eptr >= pp) |
| 2540 | { | { |
| 2541 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM19); |
| # | Line 2137 for (;;) | Line 2544 for (;;) |
| 2544 | } | } |
| 2545 | } | } |
| 2546 | ||
| 2547 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2548 | } | } |
| 2549 | } | } |
| 2550 | /* Control never gets here */ | /* Control never gets here */ |
| # | Line 2189 for (;;) | Line 2596 for (;;) |
| 2596 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 2597 | { | { |
| 2598 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 2599 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2600 | } | } |
| 2601 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 2602 | if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH); | if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH); |
| 2603 | } | } |
| 2604 | ||
| 2605 | /* If max == min we can continue with the main loop without the | /* If max == min we can continue with the main loop without the |
| # | Line 2209 for (;;) | Line 2616 for (;;) |
| 2616 | { | { |
| 2617 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM20); |
| 2618 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 2619 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 2620 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 2621 | { | { |
| 2622 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 2623 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2624 | } | } |
| 2625 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 2626 | if (!_pcre_xclass(c, data)) RRETURN(MATCH_NOMATCH); | if (!_pcre_xclass(c, data)) MRRETURN(MATCH_NOMATCH); |
| 2627 | } | } |
| 2628 | /* Control never gets here */ | /* Control never gets here */ |
| 2629 | } | } |
| # | Line 2233 for (;;) | Line 2636 for (;;) |
| 2636 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 2637 | { | { |
| 2638 | int len = 1; | int len = 1; |
| 2639 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 2640 | { | |
| 2641 | SCHECK_PARTIAL(); | |
| 2642 | break; | |
| 2643 | } | |
| 2644 | GETCHARLENTEST(c, eptr, len); | GETCHARLENTEST(c, eptr, len); |
| 2645 | if (!_pcre_xclass(c, data)) break; | if (!_pcre_xclass(c, data)) break; |
| 2646 | eptr += len; | eptr += len; |
| 2647 | } | } |
| CHECK_PARTIAL(); | ||
| 2648 | for(;;) | for(;;) |
| 2649 | { | { |
| 2650 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM21); |
| # | Line 2246 for (;;) | Line 2652 for (;;) |
| 2652 | if (eptr-- == pp) break; /* Stop if tried at original pos */ | if (eptr-- == pp) break; /* Stop if tried at original pos */ |
| 2653 | if (utf8) BACKCHAR(eptr); | if (utf8) BACKCHAR(eptr); |
| 2654 | } | } |
| 2655 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2656 | } | } |
| 2657 | ||
| 2658 | /* Control never gets here */ | /* Control never gets here */ |
| # | Line 2262 for (;;) | Line 2668 for (;;) |
| 2668 | length = 1; | length = 1; |
| 2669 | ecode++; | ecode++; |
| 2670 | GETCHARLEN(fc, ecode, length); | GETCHARLEN(fc, ecode, length); |
| 2671 | if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH); | if (length > md->end_subject - eptr) |
| 2672 | while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH); | { |
| 2673 | CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */ | |
| 2674 | MRRETURN(MATCH_NOMATCH); | |
| 2675 | } | |
| 2676 | while (length-- > 0) if (*ecode++ != *eptr++) MRRETURN(MATCH_NOMATCH); | |
| 2677 | } | } |
| 2678 | else | else |
| 2679 | #endif | #endif |
| 2680 | ||
| 2681 | /* Non-UTF-8 mode */ | /* Non-UTF-8 mode */ |
| 2682 | { | { |
| 2683 | if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH); | if (md->end_subject - eptr < 1) |
| 2684 | if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH); | { |
| 2685 | SCHECK_PARTIAL(); /* This one can use SCHECK_PARTIAL() */ | |
| 2686 | MRRETURN(MATCH_NOMATCH); | |
| 2687 | } | |
| 2688 | if (ecode[1] != *eptr++) MRRETURN(MATCH_NOMATCH); | |
| 2689 | ecode += 2; | ecode += 2; |
| 2690 | } | } |
| 2691 | break; | break; |
| # | Line 2286 for (;;) | Line 2700 for (;;) |
| 2700 | ecode++; | ecode++; |
| 2701 | GETCHARLEN(fc, ecode, length); | GETCHARLEN(fc, ecode, length); |
| 2702 | ||
| 2703 | if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH); | if (length > md->end_subject - eptr) |
| 2704 | { | |
| 2705 | CHECK_PARTIAL(); /* Not SCHECK_PARTIAL() */ | |
| 2706 | MRRETURN(MATCH_NOMATCH); | |
| 2707 | } | |
| 2708 | ||
| 2709 | /* If the pattern character's value is < 128, we have only one byte, and | /* If the pattern character's value is < 128, we have only one byte, and |
| 2710 | can use the fast lookup table. */ | can use the fast lookup table. */ |
| 2711 | ||
| 2712 | if (fc < 128) | if (fc < 128) |
| 2713 | { | { |
| 2714 | if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH); | if (md->lcc[*ecode++] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH); |
| 2715 | } | } |
| 2716 | ||
| 2717 | /* Otherwise we must pick up the subject character */ | /* Otherwise we must pick up the subject character */ |
| # | Line 2312 for (;;) | Line 2730 for (;;) |
| 2730 | #ifdef SUPPORT_UCP | #ifdef SUPPORT_UCP |
| 2731 | if (dc != UCD_OTHERCASE(fc)) | if (dc != UCD_OTHERCASE(fc)) |
| 2732 | #endif | #endif |
| 2733 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2734 | } | } |
| 2735 | } | } |
| 2736 | } | } |
| # | Line 2321 for (;;) | Line 2739 for (;;) |
| 2739 | ||
| 2740 | /* Non-UTF-8 mode */ | /* Non-UTF-8 mode */ |
| 2741 | { | { |
| 2742 | if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH); | if (md->end_subject - eptr < 1) |
| 2743 | if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH); | { |
| 2744 | SCHECK_PARTIAL(); /* This one can use SCHECK_PARTIAL() */ | |
| 2745 | MRRETURN(MATCH_NOMATCH); | |
| 2746 | } | |
| 2747 | if (md->lcc[ecode[1]] != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH); | |
| 2748 | ecode += 2; | ecode += 2; |
| 2749 | } | } |
| 2750 | break; | break; |
| # | Line 2375 for (;;) | Line 2797 for (;;) |
| 2797 | case OP_MINQUERY: | case OP_MINQUERY: |
| 2798 | c = *ecode++ - OP_STAR; | c = *ecode++ - OP_STAR; |
| 2799 | minimize = (c & 1) != 0; | minimize = (c & 1) != 0; |
| 2800 | ||
| 2801 | min = rep_min[c]; /* Pick up values from tables; */ | min = rep_min[c]; /* Pick up values from tables; */ |
| 2802 | max = rep_max[c]; /* zero for max => infinity */ | max = rep_max[c]; /* zero for max => infinity */ |
| 2803 | if (max == 0) max = INT_MAX; | if (max == 0) max = INT_MAX; |
| # | Line 2415 for (;;) | Line 2838 for (;;) |
| 2838 | else | else |
| 2839 | { | { |
| 2840 | CHECK_PARTIAL(); | CHECK_PARTIAL(); |
| 2841 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2842 | } | } |
| 2843 | } | } |
| 2844 | ||
| # | Line 2427 for (;;) | Line 2850 for (;;) |
| 2850 | { | { |
| 2851 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM22); |
| 2852 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 2853 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 2854 | if (eptr <= md->end_subject - length && | if (eptr <= md->end_subject - length && |
| 2855 | memcmp(eptr, charptr, length) == 0) eptr += length; | memcmp(eptr, charptr, length) == 0) eptr += length; |
| 2856 | #ifdef SUPPORT_UCP | #ifdef SUPPORT_UCP |
| # | Line 2442 for (;;) | Line 2861 for (;;) |
| 2861 | else | else |
| 2862 | { | { |
| 2863 | CHECK_PARTIAL(); | CHECK_PARTIAL(); |
| 2864 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2865 | } | } |
| 2866 | } | } |
| 2867 | /* Control never gets here */ | /* Control never gets here */ |
| # | Line 2460 for (;;) | Line 2879 for (;;) |
| 2879 | eptr <= md->end_subject - oclength && | eptr <= md->end_subject - oclength && |
| 2880 | memcmp(eptr, occhars, oclength) == 0) eptr += oclength; | memcmp(eptr, occhars, oclength) == 0) eptr += oclength; |
| 2881 | #endif /* SUPPORT_UCP */ | #endif /* SUPPORT_UCP */ |
| 2882 | else break; | else |
| 2883 | } | { |
| 2884 | CHECK_PARTIAL(); | |
| 2885 | CHECK_PARTIAL(); | break; |
| 2886 | if (possessive) continue; | } |
| 2887 | } | |
| 2888 | ||
| 2889 | if (possessive) continue; | |
| 2890 | ||
| 2891 | for(;;) | for(;;) |
| 2892 | { | { |
| 2893 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM23); |
| 2894 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 2895 | if (eptr == pp) { RRETURN(MATCH_NOMATCH); } | if (eptr == pp) { MRRETURN(MATCH_NOMATCH); } |
| 2896 | #ifdef SUPPORT_UCP | #ifdef SUPPORT_UCP |
| 2897 | eptr--; | eptr--; |
| 2898 | BACKCHAR(eptr); | BACKCHAR(eptr); |
| # | Line 2513 for (;;) | Line 2935 for (;;) |
| 2935 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 2936 | { | { |
| 2937 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 2938 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2939 | } | } |
| 2940 | if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH); | if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH); |
| 2941 | } | } |
| 2942 | if (min == max) continue; | if (min == max) continue; |
| 2943 | if (minimize) | if (minimize) |
| # | Line 2524 for (;;) | Line 2946 for (;;) |
| 2946 | { | { |
| 2947 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM24); |
| 2948 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 2949 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 2950 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 2951 | { | { |
| 2952 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 2953 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2954 | } | } |
| 2955 | if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH); | if (fc != md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH); |
| 2956 | } | } |
| 2957 | /* Control never gets here */ | /* Control never gets here */ |
| 2958 | } | } |
| # | Line 2543 for (;;) | Line 2961 for (;;) |
| 2961 | pp = eptr; | pp = eptr; |
| 2962 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 2963 | { | { |
| 2964 | if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break; | if (eptr >= md->end_subject) |
| 2965 | { | |
| 2966 | SCHECK_PARTIAL(); | |
| 2967 | break; | |
| 2968 | } | |
| 2969 | if (fc != md->lcc[*eptr]) break; | |
| 2970 | eptr++; | eptr++; |
| 2971 | } | } |
| 2972 | ||
| CHECK_PARTIAL(); | ||
| 2973 | if (possessive) continue; | if (possessive) continue; |
| 2974 | ||
| 2975 | while (eptr >= pp) | while (eptr >= pp) |
| # | Line 2556 for (;;) | Line 2978 for (;;) |
| 2978 | eptr--; | eptr--; |
| 2979 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 2980 | } | } |
| 2981 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2982 | } | } |
| 2983 | /* Control never gets here */ | /* Control never gets here */ |
| 2984 | } | } |
| # | Line 2570 for (;;) | Line 2992 for (;;) |
| 2992 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 2993 | { | { |
| 2994 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 2995 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 2996 | } | } |
| 2997 | if (fc != *eptr++) RRETURN(MATCH_NOMATCH); | if (fc != *eptr++) MRRETURN(MATCH_NOMATCH); |
| 2998 | } | } |
| 2999 | ||
| 3000 | if (min == max) continue; | if (min == max) continue; |
| 3001 | ||
| 3002 | if (minimize) | if (minimize) |
| 3003 | { | { |
| 3004 | for (fi = min;; fi++) | for (fi = min;; fi++) |
| 3005 | { | { |
| 3006 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM26); |
| 3007 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 3008 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 3009 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3010 | { | { |
| 3011 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3012 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3013 | } | } |
| 3014 | if (fc != *eptr++) RRETURN(MATCH_NOMATCH); | if (fc != *eptr++) MRRETURN(MATCH_NOMATCH); |
| 3015 | } | } |
| 3016 | /* Control never gets here */ | /* Control never gets here */ |
| 3017 | } | } |
| # | Line 2600 for (;;) | Line 3020 for (;;) |
| 3020 | pp = eptr; | pp = eptr; |
| 3021 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 3022 | { | { |
| 3023 | if (eptr >= md->end_subject || fc != *eptr) break; | if (eptr >= md->end_subject) |
| 3024 | { | |
| 3025 | SCHECK_PARTIAL(); | |
| 3026 | break; | |
| 3027 | } | |
| 3028 | if (fc != *eptr) break; | |
| 3029 | eptr++; | eptr++; |
| 3030 | } | } |
| CHECK_PARTIAL(); | ||
| 3031 | if (possessive) continue; | if (possessive) continue; |
| 3032 | ||
| 3033 | while (eptr >= pp) | while (eptr >= pp) |
| 3034 | { | { |
| 3035 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM27); |
| 3036 | eptr--; | eptr--; |
| 3037 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 3038 | } | } |
| 3039 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3040 | } | } |
| 3041 | } | } |
| 3042 | /* Control never gets here */ | /* Control never gets here */ |
| # | Line 2620 for (;;) | Line 3045 for (;;) |
| 3045 | checking can be multibyte. */ | checking can be multibyte. */ |
| 3046 | ||
| 3047 | case OP_NOT: | case OP_NOT: |
| 3048 | if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH); | if (eptr >= md->end_subject) |
| 3049 | { | |
| 3050 | SCHECK_PARTIAL(); | |
| 3051 | MRRETURN(MATCH_NOMATCH); | |
| 3052 | } | |
| 3053 | ecode++; | ecode++; |
| 3054 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 3055 | if ((ims & PCRE_CASELESS) != 0) | if ((ims & PCRE_CASELESS) != 0) |
| # | Line 2629 for (;;) | Line 3058 for (;;) |
| 3058 | if (c < 256) | if (c < 256) |
| 3059 | #endif | #endif |
| 3060 | c = md->lcc[c]; | c = md->lcc[c]; |
| 3061 | if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH); | if (md->lcc[*ecode++] == c) MRRETURN(MATCH_NOMATCH); |
| 3062 | } | } |
| 3063 | else | else |
| 3064 | { | { |
| 3065 | if (*ecode++ == c) RRETURN(MATCH_NOMATCH); | if (*ecode++ == c) MRRETURN(MATCH_NOMATCH); |
| 3066 | } | } |
| 3067 | break; | break; |
| 3068 | ||
| # | Line 2727 for (;;) | Line 3156 for (;;) |
| 3156 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3157 | { | { |
| 3158 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3159 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3160 | } | } |
| 3161 | GETCHARINC(d, eptr); | GETCHARINC(d, eptr); |
| 3162 | if (d < 256) d = md->lcc[d]; | if (d < 256) d = md->lcc[d]; |
| 3163 | if (fc == d) RRETURN(MATCH_NOMATCH); | if (fc == d) MRRETURN(MATCH_NOMATCH); |
| 3164 | } | } |
| 3165 | } | } |
| 3166 | else | else |
| # | Line 2744 for (;;) | Line 3173 for (;;) |
| 3173 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3174 | { | { |
| 3175 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3176 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3177 | } | } |
| 3178 | if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH); | if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH); |
| 3179 | } | } |
| 3180 | } | } |
| 3181 | ||
| # | Line 2763 for (;;) | Line 3192 for (;;) |
| 3192 | { | { |
| 3193 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM28); |
| 3194 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 3195 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 3196 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3197 | { | { |
| 3198 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3199 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3200 | } | } |
| 3201 | GETCHARINC(d, eptr); | GETCHARINC(d, eptr); |
| 3202 | if (d < 256) d = md->lcc[d]; | if (d < 256) d = md->lcc[d]; |
| 3203 | if (fc == d) RRETURN(MATCH_NOMATCH); | if (fc == d) MRRETURN(MATCH_NOMATCH); |
| 3204 | } | } |
| 3205 | } | } |
| 3206 | else | else |
| # | Line 2786 for (;;) | Line 3211 for (;;) |
| 3211 | { | { |
| 3212 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM29); |
| 3213 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 3214 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 3215 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3216 | { | { |
| 3217 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3218 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3219 | } | } |
| 3220 | if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH); | if (fc == md->lcc[*eptr++]) MRRETURN(MATCH_NOMATCH); |
| 3221 | } | } |
| 3222 | } | } |
| 3223 | /* Control never gets here */ | /* Control never gets here */ |
| # | Line 2816 for (;;) | Line 3237 for (;;) |
| 3237 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 3238 | { | { |
| 3239 | int len = 1; | int len = 1; |
| 3240 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 3241 | { | |
| 3242 | SCHECK_PARTIAL(); | |
| 3243 | break; | |
| 3244 | } | |
| 3245 | GETCHARLEN(d, eptr, len); | GETCHARLEN(d, eptr, len); |
| 3246 | if (d < 256) d = md->lcc[d]; | if (d < 256) d = md->lcc[d]; |
| 3247 | if (fc == d) break; | if (fc == d) break; |
| 3248 | eptr += len; | eptr += len; |
| 3249 | } | } |
| CHECK_PARTIAL(); | ||
| 3250 | if (possessive) continue; | if (possessive) continue; |
| 3251 | for(;;) | for(;;) |
| 3252 | { | { |
| # | Line 2838 for (;;) | Line 3262 for (;;) |
| 3262 | { | { |
| 3263 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 3264 | { | { |
| 3265 | if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break; | if (eptr >= md->end_subject) |
| 3266 | { | |
| 3267 | SCHECK_PARTIAL(); | |
| 3268 | break; | |
| 3269 | } | |
| 3270 | if (fc == md->lcc[*eptr]) break; | |
| 3271 | eptr++; | eptr++; |
| 3272 | } | } |
| CHECK_PARTIAL(); | ||
| 3273 | if (possessive) continue; | if (possessive) continue; |
| 3274 | while (eptr >= pp) | while (eptr >= pp) |
| 3275 | { | { |
| # | Line 2851 for (;;) | Line 3279 for (;;) |
| 3279 | } | } |
| 3280 | } | } |
| 3281 | ||
| 3282 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3283 | } | } |
| 3284 | /* Control never gets here */ | /* Control never gets here */ |
| 3285 | } | } |
| # | Line 2870 for (;;) | Line 3298 for (;;) |
| 3298 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3299 | { | { |
| 3300 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3301 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3302 | } | } |
| 3303 | GETCHARINC(d, eptr); | GETCHARINC(d, eptr); |
| 3304 | if (fc == d) RRETURN(MATCH_NOMATCH); | if (fc == d) MRRETURN(MATCH_NOMATCH); |
| 3305 | } | } |
| 3306 | } | } |
| 3307 | else | else |
| # | Line 2885 for (;;) | Line 3313 for (;;) |
| 3313 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3314 | { | { |
| 3315 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3316 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3317 | } | } |
| 3318 | if (fc == *eptr++) RRETURN(MATCH_NOMATCH); | if (fc == *eptr++) MRRETURN(MATCH_NOMATCH); |
| 3319 | } | } |
| 3320 | } | } |
| 3321 | ||
| # | Line 2904 for (;;) | Line 3332 for (;;) |
| 3332 | { | { |
| 3333 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM32); |
| 3334 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 3335 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 3336 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3337 | { | { |
| 3338 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3339 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3340 | } | } |
| 3341 | GETCHARINC(d, eptr); | GETCHARINC(d, eptr); |
| 3342 | if (fc == d) RRETURN(MATCH_NOMATCH); | if (fc == d) MRRETURN(MATCH_NOMATCH); |
| 3343 | } | } |
| 3344 | } | } |
| 3345 | else | else |
| # | Line 2926 for (;;) | Line 3350 for (;;) |
| 3350 | { | { |
| 3351 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM33); |
| 3352 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 3353 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 3354 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3355 | { | { |
| 3356 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3357 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3358 | } | } |
| 3359 | if (fc == *eptr++) RRETURN(MATCH_NOMATCH); | if (fc == *eptr++) MRRETURN(MATCH_NOMATCH); |
| 3360 | } | } |
| 3361 | } | } |
| 3362 | /* Control never gets here */ | /* Control never gets here */ |
| # | Line 2956 for (;;) | Line 3376 for (;;) |
| 3376 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 3377 | { | { |
| 3378 | int len = 1; | int len = 1; |
| 3379 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 3380 | { | |
| 3381 | SCHECK_PARTIAL(); | |
| 3382 | break; | |
| 3383 | } | |
| 3384 | GETCHARLEN(d, eptr, len); | GETCHARLEN(d, eptr, len); |
| 3385 | if (fc == d) break; | if (fc == d) break; |
| 3386 | eptr += len; | eptr += len; |
| 3387 | } | } |
| CHECK_PARTIAL(); | ||
| 3388 | if (possessive) continue; | if (possessive) continue; |
| 3389 | for(;;) | for(;;) |
| 3390 | { | { |
| # | Line 2977 for (;;) | Line 3400 for (;;) |
| 3400 | { | { |
| 3401 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 3402 | { | { |
| 3403 | if (eptr >= md->end_subject || fc == *eptr) break; | if (eptr >= md->end_subject) |
| 3404 | { | |
| 3405 | SCHECK_PARTIAL(); | |
| 3406 | break; | |
| 3407 | } | |
| 3408 | if (fc == *eptr) break; | |
| 3409 | eptr++; | eptr++; |
| 3410 | } | } |
| CHECK_PARTIAL(); | ||
| 3411 | if (possessive) continue; | if (possessive) continue; |
| 3412 | while (eptr >= pp) | while (eptr >= pp) |
| 3413 | { | { |
| # | Line 2990 for (;;) | Line 3417 for (;;) |
| 3417 | } | } |
| 3418 | } | } |
| 3419 | ||
| 3420 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3421 | } | } |
| 3422 | } | } |
| 3423 | /* Control never gets here */ | /* Control never gets here */ |
| # | Line 3084 for (;;) | Line 3511 for (;;) |
| 3511 | switch(prop_type) | switch(prop_type) |
| 3512 | { | { |
| 3513 | case PT_ANY: | case PT_ANY: |
| 3514 | if (prop_fail_result) RRETURN(MATCH_NOMATCH); | if (prop_fail_result) MRRETURN(MATCH_NOMATCH); |
| 3515 | for (i = 1; i <= min; i++) | for (i = 1; i <= min; i++) |
| 3516 | { | { |
| 3517 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3518 | { | { |
| 3519 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3520 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3521 | } | } |
| 3522 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 3523 | } | } |
| # | Line 3102 for (;;) | Line 3529 for (;;) |
| 3529 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3530 | { | { |
| 3531 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3532 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3533 | } | } |
| 3534 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 3535 | prop_chartype = UCD_CHARTYPE(c); | prop_chartype = UCD_CHARTYPE(c); |
| 3536 | if ((prop_chartype == ucp_Lu || | if ((prop_chartype == ucp_Lu || |
| 3537 | prop_chartype == ucp_Ll || | prop_chartype == ucp_Ll || |
| 3538 | prop_chartype == ucp_Lt) == prop_fail_result) | prop_chartype == ucp_Lt) == prop_fail_result) |
| 3539 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3540 | } | } |
| 3541 | break; | break; |
| 3542 | ||
| # | Line 3119 for (;;) | Line 3546 for (;;) |
| 3546 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3547 | { | { |
| 3548 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3549 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3550 | } | } |
| 3551 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 3552 | prop_category = UCD_CATEGORY(c); | prop_category = UCD_CATEGORY(c); |
| 3553 | if ((prop_category == prop_value) == prop_fail_result) | if ((prop_category == prop_value) == prop_fail_result) |
| 3554 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3555 | } | } |
| 3556 | break; | break; |
| 3557 | ||
| # | Line 3134 for (;;) | Line 3561 for (;;) |
| 3561 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3562 | { | { |
| 3563 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3564 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3565 | } | } |
| 3566 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 3567 | prop_chartype = UCD_CHARTYPE(c); | prop_chartype = UCD_CHARTYPE(c); |
| 3568 | if ((prop_chartype == prop_value) == prop_fail_result) | if ((prop_chartype == prop_value) == prop_fail_result) |
| 3569 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3570 | } | } |
| 3571 | break; | break; |
| 3572 | ||
| # | Line 3149 for (;;) | Line 3576 for (;;) |
| 3576 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3577 | { | { |
| 3578 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3579 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3580 | } | } |
| 3581 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 3582 | prop_script = UCD_SCRIPT(c); | prop_script = UCD_SCRIPT(c); |
| 3583 | if ((prop_script == prop_value) == prop_fail_result) | if ((prop_script == prop_value) == prop_fail_result) |
| 3584 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3585 | } | |
| 3586 | break; | |
| 3587 | ||
| 3588 | case PT_ALNUM: | |
| 3589 | for (i = 1; i <= min; i++) | |
| 3590 | { | |
| 3591 | if (eptr >= md->end_subject) | |
| 3592 | { | |
| 3593 | SCHECK_PARTIAL(); | |
| 3594 | MRRETURN(MATCH_NOMATCH); | |
| 3595 | } | |
| 3596 | GETCHARINCTEST(c, eptr); | |
| 3597 | prop_category = UCD_CATEGORY(c); | |
| 3598 | if ((prop_category == ucp_L || prop_category == ucp_N) | |
| 3599 | == prop_fail_result) | |
| 3600 | MRRETURN(MATCH_NOMATCH); | |
| 3601 | } | |
| 3602 | break; | |
| 3603 | ||
| 3604 | case PT_SPACE: /* Perl space */ | |
| 3605 | for (i = 1; i <= min; i++) | |
| 3606 | { | |
| 3607 | if (eptr >= md->end_subject) | |
| 3608 | { | |
| 3609 | SCHECK_PARTIAL(); | |
| 3610 | MRRETURN(MATCH_NOMATCH); | |
| 3611 | } | |
| 3612 | GETCHARINCTEST(c, eptr); | |
| 3613 | prop_category = UCD_CATEGORY(c); | |
| 3614 | if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL || | |
| 3615 | c == CHAR_FF || c == CHAR_CR) | |
| 3616 | == prop_fail_result) | |
| 3617 | MRRETURN(MATCH_NOMATCH); | |
| 3618 | } | |
| 3619 | break; | |
| 3620 | ||
| 3621 | case PT_PXSPACE: /* POSIX space */ | |
| 3622 | for (i = 1; i <= min; i++) | |
| 3623 | { | |
| 3624 | if (eptr >= md->end_subject) | |
| 3625 | { | |
| 3626 | SCHECK_PARTIAL(); | |
| 3627 | MRRETURN(MATCH_NOMATCH); | |
| 3628 | } | |
| 3629 | GETCHARINCTEST(c, eptr); | |
| 3630 | prop_category = UCD_CATEGORY(c); | |
| 3631 | if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL || | |
| 3632 | c == CHAR_VT || c == CHAR_FF || c == CHAR_CR) | |
| 3633 | == prop_fail_result) | |
| 3634 | MRRETURN(MATCH_NOMATCH); | |
| 3635 | } | |
| 3636 | break; | |
| 3637 | ||
| 3638 | case PT_WORD: | |
| 3639 | for (i = 1; i <= min; i++) | |
| 3640 | { | |
| 3641 | if (eptr >= md->end_subject) | |
| 3642 | { | |
| 3643 | SCHECK_PARTIAL(); | |
| 3644 | MRRETURN(MATCH_NOMATCH); | |
| 3645 | } | |
| 3646 | GETCHARINCTEST(c, eptr); | |
| 3647 | prop_category = UCD_CATEGORY(c); | |
| 3648 | if ((prop_category == ucp_L || prop_category == ucp_N || | |
| 3649 | c == CHAR_UNDERSCORE) | |
| 3650 | == prop_fail_result) | |
| 3651 | MRRETURN(MATCH_NOMATCH); | |
| 3652 | } | } |
| 3653 | break; | break; |
| 3654 | ||
| 3655 | /* This should not occur */ | |
| 3656 | ||
| 3657 | default: | default: |
| 3658 | RRETURN(PCRE_ERROR_INTERNAL); | RRETURN(PCRE_ERROR_INTERNAL); |
| 3659 | } | } |
| # | Line 3173 for (;;) | Line 3669 for (;;) |
| 3669 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3670 | { | { |
| 3671 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3672 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3673 | } | } |
| 3674 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 3675 | prop_category = UCD_CATEGORY(c); | prop_category = UCD_CATEGORY(c); |
| 3676 | if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH); | if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH); |
| 3677 | while (eptr < md->end_subject) | while (eptr < md->end_subject) |
| 3678 | { | { |
| 3679 | int len = 1; | int len = 1; |
| # | Line 3204 for (;;) | Line 3700 for (;;) |
| 3700 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3701 | { | { |
| 3702 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3703 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3704 | } | } |
| 3705 | if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); | if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); |
| 3706 | eptr++; | eptr++; |
| 3707 | while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; | while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; |
| 3708 | } | } |
| # | Line 3218 for (;;) | Line 3714 for (;;) |
| 3714 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3715 | { | { |
| 3716 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3717 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3718 | } | } |
| 3719 | eptr++; | eptr++; |
| 3720 | while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; | while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; |
| # | Line 3226 for (;;) | Line 3722 for (;;) |
| 3722 | break; | break; |
| 3723 | ||
| 3724 | case OP_ANYBYTE: | case OP_ANYBYTE: |
| 3725 | if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH); | if (eptr > md->end_subject - min) MRRETURN(MATCH_NOMATCH); |
| 3726 | eptr += min; | eptr += min; |
| 3727 | break; | break; |
| 3728 | ||
| # | Line 3236 for (;;) | Line 3732 for (;;) |
| 3732 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3733 | { | { |
| 3734 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3735 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3736 | } | } |
| 3737 | GETCHARINC(c, eptr); | GETCHARINC(c, eptr); |
| 3738 | switch(c) | switch(c) |
| 3739 | { | { |
| 3740 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 3741 | case 0x000d: | case 0x000d: |
| 3742 | if (eptr < md->end_subject && *eptr == 0x0a) eptr++; | if (eptr < md->end_subject && *eptr == 0x0a) eptr++; |
| 3743 | break; | break; |
| # | Line 3254 for (;;) | Line 3750 for (;;) |
| 3750 | case 0x0085: | case 0x0085: |
| 3751 | case 0x2028: | case 0x2028: |
| 3752 | case 0x2029: | case 0x2029: |
| 3753 | if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH); | if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH); |
| 3754 | break; | break; |
| 3755 | } | } |
| 3756 | } | } |
| # | Line 3266 for (;;) | Line 3762 for (;;) |
| 3762 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3763 | { | { |
| 3764 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3765 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3766 | } | } |
| 3767 | GETCHARINC(c, eptr); | GETCHARINC(c, eptr); |
| 3768 | switch(c) | switch(c) |
| # | Line 3291 for (;;) | Line 3787 for (;;) |
| 3787 | case 0x202f: /* NARROW NO-BREAK SPACE */ | case 0x202f: /* NARROW NO-BREAK SPACE */ |
| 3788 | case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ | case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ |
| 3789 | case 0x3000: /* IDEOGRAPHIC SPACE */ | case 0x3000: /* IDEOGRAPHIC SPACE */ |
| 3790 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3791 | } | } |
| 3792 | } | } |
| 3793 | break; | break; |
| # | Line 3302 for (;;) | Line 3798 for (;;) |
| 3798 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3799 | { | { |
| 3800 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3801 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3802 | } | } |
| 3803 | GETCHARINC(c, eptr); | GETCHARINC(c, eptr); |
| 3804 | switch(c) | switch(c) |
| 3805 | { | { |
| 3806 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 3807 | case 0x09: /* HT */ | case 0x09: /* HT */ |
| 3808 | case 0x20: /* SPACE */ | case 0x20: /* SPACE */ |
| 3809 | case 0xa0: /* NBSP */ | case 0xa0: /* NBSP */ |
| # | Line 3338 for (;;) | Line 3834 for (;;) |
| 3834 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3835 | { | { |
| 3836 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3837 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3838 | } | } |
| 3839 | GETCHARINC(c, eptr); | GETCHARINC(c, eptr); |
| 3840 | switch(c) | switch(c) |
| # | Line 3351 for (;;) | Line 3847 for (;;) |
| 3847 | case 0x85: /* NEL */ | case 0x85: /* NEL */ |
| 3848 | case 0x2028: /* LINE SEPARATOR */ | case 0x2028: /* LINE SEPARATOR */ |
| 3849 | case 0x2029: /* PARAGRAPH SEPARATOR */ | case 0x2029: /* PARAGRAPH SEPARATOR */ |
| 3850 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3851 | } | } |
| 3852 | } | } |
| 3853 | break; | break; |
| # | Line 3362 for (;;) | Line 3858 for (;;) |
| 3858 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3859 | { | { |
| 3860 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3861 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3862 | } | } |
| 3863 | GETCHARINC(c, eptr); | GETCHARINC(c, eptr); |
| 3864 | switch(c) | switch(c) |
| 3865 | { | { |
| 3866 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 3867 | case 0x0a: /* LF */ | case 0x0a: /* LF */ |
| 3868 | case 0x0b: /* VT */ | case 0x0b: /* VT */ |
| 3869 | case 0x0c: /* FF */ | case 0x0c: /* FF */ |
| # | Line 3386 for (;;) | Line 3882 for (;;) |
| 3882 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3883 | { | { |
| 3884 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3885 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3886 | } | } |
| 3887 | GETCHARINC(c, eptr); | GETCHARINC(c, eptr); |
| 3888 | if (c < 128 && (md->ctypes[c] & ctype_digit) != 0) | if (c < 128 && (md->ctypes[c] & ctype_digit) != 0) |
| 3889 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3890 | } | } |
| 3891 | break; | break; |
| 3892 | ||
| # | Line 3400 for (;;) | Line 3896 for (;;) |
| 3896 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3897 | { | { |
| 3898 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3899 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3900 | } | } |
| 3901 | if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0) | if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0) |
| 3902 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3903 | /* No need to skip more bytes - we know it's a 1-byte character */ | /* No need to skip more bytes - we know it's a 1-byte character */ |
| 3904 | } | } |
| 3905 | break; | break; |
| # | Line 3414 for (;;) | Line 3910 for (;;) |
| 3910 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3911 | { | { |
| 3912 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3913 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3914 | } | } |
| 3915 | if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0) | if (*eptr < 128 && (md->ctypes[*eptr] & ctype_space) != 0) |
| 3916 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3917 | while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80); | while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80); |
| 3918 | } | } |
| 3919 | break; | break; |
| # | Line 3428 for (;;) | Line 3924 for (;;) |
| 3924 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3925 | { | { |
| 3926 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3927 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3928 | } | } |
| 3929 | if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0) | if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0) |
| 3930 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3931 | /* No need to skip more bytes - we know it's a 1-byte character */ | /* No need to skip more bytes - we know it's a 1-byte character */ |
| 3932 | } | } |
| 3933 | break; | break; |
| # | Line 3439 for (;;) | Line 3935 for (;;) |
| 3935 | case OP_NOT_WORDCHAR: | case OP_NOT_WORDCHAR: |
| 3936 | for (i = 1; i <= min; i++) | for (i = 1; i <= min; i++) |
| 3937 | { | { |
| 3938 | if (eptr >= md->end_subject || | if (eptr >= md->end_subject) |
| 3939 | (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0)) | { |
| 3940 | RRETURN(MATCH_NOMATCH); | SCHECK_PARTIAL(); |
| 3941 | MRRETURN(MATCH_NOMATCH); | |
| 3942 | } | |
| 3943 | if (*eptr < 128 && (md->ctypes[*eptr] & ctype_word) != 0) | |
| 3944 | MRRETURN(MATCH_NOMATCH); | |
| 3945 | while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80); | while (++eptr < md->end_subject && (*eptr & 0xc0) == 0x80); |
| 3946 | } | } |
| 3947 | break; | break; |
| # | Line 3452 for (;;) | Line 3952 for (;;) |
| 3952 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3953 | { | { |
| 3954 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3955 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3956 | } | } |
| 3957 | if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0) | if (*eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0) |
| 3958 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3959 | /* No need to skip more bytes - we know it's a 1-byte character */ | /* No need to skip more bytes - we know it's a 1-byte character */ |
| 3960 | } | } |
| 3961 | break; | break; |
| # | Line 3478 for (;;) | Line 3978 for (;;) |
| 3978 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 3979 | { | { |
| 3980 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 3981 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 3982 | } | } |
| 3983 | if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH); | if (IS_NEWLINE(eptr)) MRRETURN(MATCH_NOMATCH); |
| 3984 | eptr++; | eptr++; |
| 3985 | } | } |
| 3986 | break; | break; |
| 3987 | ||
| 3988 | case OP_ALLANY: | case OP_ALLANY: |
| 3989 | if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH); | if (eptr > md->end_subject - min) |
| 3990 | { | |
| 3991 | SCHECK_PARTIAL(); | |
| 3992 | MRRETURN(MATCH_NOMATCH); | |
| 3993 | } | |
| 3994 | eptr += min; | eptr += min; |
| 3995 | break; | break; |
| 3996 | ||
| 3997 | case OP_ANYBYTE: | case OP_ANYBYTE: |
| 3998 | if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH); | if (eptr > md->end_subject - min) |
| 3999 | { | |
| 4000 | SCHECK_PARTIAL(); | |
| 4001 | MRRETURN(MATCH_NOMATCH); | |
| 4002 | } | |
| 4003 | eptr += min; | eptr += min; |
| 4004 | break; | break; |
| 4005 | ||
| # | Line 3501 for (;;) | Line 4009 for (;;) |
| 4009 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4010 | { | { |
| 4011 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4012 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4013 | } | } |
| 4014 | switch(*eptr++) | switch(*eptr++) |
| 4015 | { | { |
| 4016 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 4017 | case 0x000d: | case 0x000d: |
| 4018 | if (eptr < md->end_subject && *eptr == 0x0a) eptr++; | if (eptr < md->end_subject && *eptr == 0x0a) eptr++; |
| 4019 | break; | break; |
| # | Line 3515 for (;;) | Line 4023 for (;;) |
| 4023 | case 0x000b: | case 0x000b: |
| 4024 | case 0x000c: | case 0x000c: |
| 4025 | case 0x0085: | case 0x0085: |
| 4026 | if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH); | if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH); |
| 4027 | break; | break; |
| 4028 | } | } |
| 4029 | } | } |
| # | Line 3527 for (;;) | Line 4035 for (;;) |
| 4035 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4036 | { | { |
| 4037 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4038 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4039 | } | } |
| 4040 | switch(*eptr++) | switch(*eptr++) |
| 4041 | { | { |
| # | Line 3535 for (;;) | Line 4043 for (;;) |
| 4043 | case 0x09: /* HT */ | case 0x09: /* HT */ |
| 4044 | case 0x20: /* SPACE */ | case 0x20: /* SPACE */ |
| 4045 | case 0xa0: /* NBSP */ | case 0xa0: /* NBSP */ |
| 4046 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4047 | } | } |
| 4048 | } | } |
| 4049 | break; | break; |
| # | Line 3546 for (;;) | Line 4054 for (;;) |
| 4054 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4055 | { | { |
| 4056 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4057 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4058 | } | } |
| 4059 | switch(*eptr++) | switch(*eptr++) |
| 4060 | { | { |
| 4061 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 4062 | case 0x09: /* HT */ | case 0x09: /* HT */ |
| 4063 | case 0x20: /* SPACE */ | case 0x20: /* SPACE */ |
| 4064 | case 0xa0: /* NBSP */ | case 0xa0: /* NBSP */ |
| # | Line 3565 for (;;) | Line 4073 for (;;) |
| 4073 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4074 | { | { |
| 4075 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4076 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4077 | } | } |
| 4078 | switch(*eptr++) | switch(*eptr++) |
| 4079 | { | { |
| # | Line 3575 for (;;) | Line 4083 for (;;) |
| 4083 | case 0x0c: /* FF */ | case 0x0c: /* FF */ |
| 4084 | case 0x0d: /* CR */ | case 0x0d: /* CR */ |
| 4085 | case 0x85: /* NEL */ | case 0x85: /* NEL */ |
| 4086 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4087 | } | } |
| 4088 | } | } |
| 4089 | break; | break; |
| # | Line 3586 for (;;) | Line 4094 for (;;) |
| 4094 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4095 | { | { |
| 4096 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4097 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4098 | } | } |
| 4099 | switch(*eptr++) | switch(*eptr++) |
| 4100 | { | { |
| 4101 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 4102 | case 0x0a: /* LF */ | case 0x0a: /* LF */ |
| 4103 | case 0x0b: /* VT */ | case 0x0b: /* VT */ |
| 4104 | case 0x0c: /* FF */ | case 0x0c: /* FF */ |
| # | Line 3607 for (;;) | Line 4115 for (;;) |
| 4115 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4116 | { | { |
| 4117 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4118 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4119 | } | } |
| 4120 | if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH); | if ((md->ctypes[*eptr++] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH); |
| 4121 | } | } |
| 4122 | break; | break; |
| 4123 | ||
| # | Line 3619 for (;;) | Line 4127 for (;;) |
| 4127 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4128 | { | { |
| 4129 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4130 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4131 | } | } |
| 4132 | if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH); | if ((md->ctypes[*eptr++] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH); |
| 4133 | } | } |
| 4134 | break; | break; |
| 4135 | ||
| # | Line 3631 for (;;) | Line 4139 for (;;) |
| 4139 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4140 | { | { |
| 4141 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4142 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4143 | } | } |
| 4144 | if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH); | if ((md->ctypes[*eptr++] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH); |
| 4145 | } | } |
| 4146 | break; | break; |
| 4147 | ||
| # | Line 3643 for (;;) | Line 4151 for (;;) |
| 4151 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4152 | { | { |
| 4153 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4154 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4155 | } | } |
| 4156 | if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH); | if ((md->ctypes[*eptr++] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH); |
| 4157 | } | } |
| 4158 | break; | break; |
| 4159 | ||
| # | Line 3655 for (;;) | Line 4163 for (;;) |
| 4163 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4164 | { | { |
| 4165 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4166 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4167 | } | } |
| 4168 | if ((md->ctypes[*eptr++] & ctype_word) != 0) | if ((md->ctypes[*eptr++] & ctype_word) != 0) |
| 4169 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4170 | } | } |
| 4171 | break; | break; |
| 4172 | ||
| # | Line 3668 for (;;) | Line 4176 for (;;) |
| 4176 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4177 | { | { |
| 4178 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4179 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4180 | } | } |
| 4181 | if ((md->ctypes[*eptr++] & ctype_word) == 0) | if ((md->ctypes[*eptr++] & ctype_word) == 0) |
| 4182 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4183 | } | } |
| 4184 | break; | break; |
| 4185 | ||
| # | Line 3700 for (;;) | Line 4208 for (;;) |
| 4208 | { | { |
| 4209 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM36); |
| 4210 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 4211 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 4212 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4213 | { | { |
| 4214 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4215 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4216 | } | } |
| 4217 | GETCHARINC(c, eptr); | GETCHARINCTEST(c, eptr); |
| 4218 | if (prop_fail_result) RRETURN(MATCH_NOMATCH); | if (prop_fail_result) MRRETURN(MATCH_NOMATCH); |
| 4219 | } | } |
| 4220 | /* Control never gets here */ | /* Control never gets here */ |
| 4221 | ||
| # | Line 3720 for (;;) | Line 4224 for (;;) |
| 4224 | { | { |
| 4225 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM37); |
| 4226 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 4227 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 4228 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4229 | { | { |
| 4230 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4231 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4232 | } | } |
| 4233 | GETCHARINC(c, eptr); | GETCHARINCTEST(c, eptr); |
| 4234 | prop_chartype = UCD_CHARTYPE(c); | prop_chartype = UCD_CHARTYPE(c); |
| 4235 | if ((prop_chartype == ucp_Lu || | if ((prop_chartype == ucp_Lu || |
| 4236 | prop_chartype == ucp_Ll || | prop_chartype == ucp_Ll || |
| 4237 | prop_chartype == ucp_Lt) == prop_fail_result) | prop_chartype == ucp_Lt) == prop_fail_result) |
| 4238 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4239 | } | } |
| 4240 | /* Control never gets here */ | /* Control never gets here */ |
| 4241 | ||
| # | Line 3744 for (;;) | Line 4244 for (;;) |
| 4244 | { | { |
| 4245 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM38); |
| 4246 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 4247 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 4248 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4249 | { | { |
| 4250 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4251 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4252 | } | } |
| 4253 | GETCHARINC(c, eptr); | GETCHARINCTEST(c, eptr); |
| 4254 | prop_category = UCD_CATEGORY(c); | prop_category = UCD_CATEGORY(c); |
| 4255 | if ((prop_category == prop_value) == prop_fail_result) | if ((prop_category == prop_value) == prop_fail_result) |
| 4256 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4257 | } | } |
| 4258 | /* Control never gets here */ | /* Control never gets here */ |
| 4259 | ||
| # | Line 3766 for (;;) | Line 4262 for (;;) |
| 4262 | { | { |
| 4263 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM39); |
| 4264 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 4265 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 4266 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4267 | { | { |
| 4268 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4269 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4270 | } | } |
| 4271 | GETCHARINC(c, eptr); | GETCHARINCTEST(c, eptr); |
| 4272 | prop_chartype = UCD_CHARTYPE(c); | prop_chartype = UCD_CHARTYPE(c); |
| 4273 | if ((prop_chartype == prop_value) == prop_fail_result) | if ((prop_chartype == prop_value) == prop_fail_result) |
| 4274 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4275 | } | } |
| 4276 | /* Control never gets here */ | /* Control never gets here */ |
| 4277 | ||
| # | Line 3788 for (;;) | Line 4280 for (;;) |
| 4280 | { | { |
| 4281 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM40); |
| 4282 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 4283 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 4284 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4285 | { | { |
| 4286 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4287 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4288 | } | } |
| 4289 | GETCHARINC(c, eptr); | GETCHARINCTEST(c, eptr); |
| 4290 | prop_script = UCD_SCRIPT(c); | prop_script = UCD_SCRIPT(c); |
| 4291 | if ((prop_script == prop_value) == prop_fail_result) | if ((prop_script == prop_value) == prop_fail_result) |
| 4292 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4293 | } | |
| 4294 | /* Control never gets here */ | |
| 4295 | ||
| 4296 | case PT_ALNUM: | |
| 4297 | for (fi = min;; fi++) | |
| 4298 | { | |
| 4299 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM59); | |
| 4300 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | |
| 4301 | if (fi >= max) MRRETURN(MATCH_NOMATCH); | |
| 4302 | if (eptr >= md->end_subject) | |
| 4303 | { | |
| 4304 | SCHECK_PARTIAL(); | |
| 4305 | MRRETURN(MATCH_NOMATCH); | |
| 4306 | } | |
| 4307 | GETCHARINCTEST(c, eptr); | |
| 4308 | prop_category = UCD_CATEGORY(c); | |
| 4309 | if ((prop_category == ucp_L || prop_category == ucp_N) | |
| 4310 | == prop_fail_result) | |
| 4311 | MRRETURN(MATCH_NOMATCH); | |
| 4312 | } | } |
| 4313 | /* Control never gets here */ | /* Control never gets here */ |
| 4314 | ||
| 4315 | case PT_SPACE: /* Perl space */ | |
| 4316 | for (fi = min;; fi++) | |
| 4317 | { | |
| 4318 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM60); | |
| 4319 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | |
| 4320 | if (fi >= max) MRRETURN(MATCH_NOMATCH); | |
| 4321 | if (eptr >= md->end_subject) | |
| 4322 | { | |
| 4323 | SCHECK_PARTIAL(); | |
| 4324 | MRRETURN(MATCH_NOMATCH); | |
| 4325 | } | |
| 4326 | GETCHARINCTEST(c, eptr); | |
| 4327 | prop_category = UCD_CATEGORY(c); | |
| 4328 | if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL || | |
| 4329 | c == CHAR_FF || c == CHAR_CR) | |
| 4330 | == prop_fail_result) | |
| 4331 | MRRETURN(MATCH_NOMATCH); | |
| 4332 | } | |
| 4333 | /* Control never gets here */ | |
| 4334 | ||
| 4335 | case PT_PXSPACE: /* POSIX space */ | |
| 4336 | for (fi = min;; fi++) | |
| 4337 | { | |
| 4338 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM61); | |
| 4339 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | |
| 4340 | if (fi >= max) MRRETURN(MATCH_NOMATCH); | |
| 4341 | if (eptr >= md->end_subject) | |
| 4342 | { | |
| 4343 | SCHECK_PARTIAL(); | |
| 4344 | MRRETURN(MATCH_NOMATCH); | |
| 4345 | } | |
| 4346 | GETCHARINCTEST(c, eptr); | |
| 4347 | prop_category = UCD_CATEGORY(c); | |
| 4348 | if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL || | |
| 4349 | c == CHAR_VT || c == CHAR_FF || c == CHAR_CR) | |
| 4350 | == prop_fail_result) | |
| 4351 | MRRETURN(MATCH_NOMATCH); | |
| 4352 | } | |
| 4353 | /* Control never gets here */ | |
| 4354 | ||
| 4355 | case PT_WORD: | |
| 4356 | for (fi = min;; fi++) | |
| 4357 | { | |
| 4358 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM62); | |
| 4359 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | |
| 4360 | if (fi >= max) MRRETURN(MATCH_NOMATCH); | |
| 4361 | if (eptr >= md->end_subject) | |
| 4362 | { | |
| 4363 | SCHECK_PARTIAL(); | |
| 4364 | MRRETURN(MATCH_NOMATCH); | |
| 4365 | } | |
| 4366 | GETCHARINCTEST(c, eptr); | |
| 4367 | prop_category = UCD_CATEGORY(c); | |
| 4368 | if ((prop_category == ucp_L || | |
| 4369 | prop_category == ucp_N || | |
| 4370 | c == CHAR_UNDERSCORE) | |
| 4371 | == prop_fail_result) | |
| 4372 | MRRETURN(MATCH_NOMATCH); | |
| 4373 | } | |
| 4374 | /* Control never gets here */ | |
| 4375 | ||
| 4376 | /* This should never occur */ | |
| 4377 | ||
| 4378 | default: | default: |
| 4379 | RRETURN(PCRE_ERROR_INTERNAL); | RRETURN(PCRE_ERROR_INTERNAL); |
| 4380 | } | } |
| # | Line 3819 for (;;) | Line 4389 for (;;) |
| 4389 | { | { |
| 4390 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM41); |
| 4391 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 4392 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 4393 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4394 | { | { |
| 4395 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4396 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4397 | } | } |
| 4398 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 4399 | prop_category = UCD_CATEGORY(c); | prop_category = UCD_CATEGORY(c); |
| 4400 | if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH); | if (prop_category == ucp_M) MRRETURN(MATCH_NOMATCH); |
| 4401 | while (eptr < md->end_subject) | while (eptr < md->end_subject) |
| 4402 | { | { |
| 4403 | int len = 1; | int len = 1; |
| # | Line 3855 for (;;) | Line 4421 for (;;) |
| 4421 | { | { |
| 4422 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM42); |
| 4423 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 4424 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 4425 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4426 | { | { |
| 4427 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4428 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4429 | } | } |
| 4430 | if (ctype == OP_ANY && IS_NEWLINE(eptr)) | if (ctype == OP_ANY && IS_NEWLINE(eptr)) |
| 4431 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4432 | GETCHARINC(c, eptr); | GETCHARINC(c, eptr); |
| 4433 | switch(ctype) | switch(ctype) |
| 4434 | { | { |
| # | Line 3878 for (;;) | Line 4440 for (;;) |
| 4440 | case OP_ANYNL: | case OP_ANYNL: |
| 4441 | switch(c) | switch(c) |
| 4442 | { | { |
| 4443 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 4444 | case 0x000d: | case 0x000d: |
| 4445 | if (eptr < md->end_subject && *eptr == 0x0a) eptr++; | if (eptr < md->end_subject && *eptr == 0x0a) eptr++; |
| 4446 | break; | break; |
| # | Line 3890 for (;;) | Line 4452 for (;;) |
| 4452 | case 0x0085: | case 0x0085: |
| 4453 | case 0x2028: | case 0x2028: |
| 4454 | case 0x2029: | case 0x2029: |
| 4455 | if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH); | if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH); |
| 4456 | break; | break; |
| 4457 | } | } |
| 4458 | break; | break; |
| # | Line 3918 for (;;) | Line 4480 for (;;) |
| 4480 | case 0x202f: /* NARROW NO-BREAK SPACE */ | case 0x202f: /* NARROW NO-BREAK SPACE */ |
| 4481 | case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ | case 0x205f: /* MEDIUM MATHEMATICAL SPACE */ |
| 4482 | case 0x3000: /* IDEOGRAPHIC SPACE */ | case 0x3000: /* IDEOGRAPHIC SPACE */ |
| 4483 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4484 | } | } |
| 4485 | break; | break; |
| 4486 | ||
| 4487 | case OP_HSPACE: | case OP_HSPACE: |
| 4488 | switch(c) | switch(c) |
| 4489 | { | { |
| 4490 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 4491 | case 0x09: /* HT */ | case 0x09: /* HT */ |
| 4492 | case 0x20: /* SPACE */ | case 0x20: /* SPACE */ |
| 4493 | case 0xa0: /* NBSP */ | case 0xa0: /* NBSP */ |
| # | Line 3960 for (;;) | Line 4522 for (;;) |
| 4522 | case 0x85: /* NEL */ | case 0x85: /* NEL */ |
| 4523 | case 0x2028: /* LINE SEPARATOR */ | case 0x2028: /* LINE SEPARATOR */ |
| 4524 | case 0x2029: /* PARAGRAPH SEPARATOR */ | case 0x2029: /* PARAGRAPH SEPARATOR */ |
| 4525 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4526 | } | } |
| 4527 | break; | break; |
| 4528 | ||
| 4529 | case OP_VSPACE: | case OP_VSPACE: |
| 4530 | switch(c) | switch(c) |
| 4531 | { | { |
| 4532 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 4533 | case 0x0a: /* LF */ | case 0x0a: /* LF */ |
| 4534 | case 0x0b: /* VT */ | case 0x0b: /* VT */ |
| 4535 | case 0x0c: /* FF */ | case 0x0c: /* FF */ |
| # | Line 3981 for (;;) | Line 4543 for (;;) |
| 4543 | ||
| 4544 | case OP_NOT_DIGIT: | case OP_NOT_DIGIT: |
| 4545 | if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) | if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) |
| 4546 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4547 | break; | break; |
| 4548 | ||
| 4549 | case OP_DIGIT: | case OP_DIGIT: |
| 4550 | if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0) | if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0) |
| 4551 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4552 | break; | break; |
| 4553 | ||
| 4554 | case OP_NOT_WHITESPACE: | case OP_NOT_WHITESPACE: |
| 4555 | if (c < 256 && (md->ctypes[c] & ctype_space) != 0) | if (c < 256 && (md->ctypes[c] & ctype_space) != 0) |
| 4556 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4557 | break; | break; |
| 4558 | ||
| 4559 | case OP_WHITESPACE: | case OP_WHITESPACE: |
| 4560 | if (c >= 256 || (md->ctypes[c] & ctype_space) == 0) | if (c >= 256 || (md->ctypes[c] & ctype_space) == 0) |
| 4561 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4562 | break; | break; |
| 4563 | ||
| 4564 | case OP_NOT_WORDCHAR: | case OP_NOT_WORDCHAR: |
| 4565 | if (c < 256 && (md->ctypes[c] & ctype_word) != 0) | if (c < 256 && (md->ctypes[c] & ctype_word) != 0) |
| 4566 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4567 | break; | break; |
| 4568 | ||
| 4569 | case OP_WORDCHAR: | case OP_WORDCHAR: |
| 4570 | if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) | if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) |
| 4571 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4572 | break; | break; |
| 4573 | ||
| 4574 | default: | default: |
| # | Line 4022 for (;;) | Line 4584 for (;;) |
| 4584 | { | { |
| 4585 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM43); |
| 4586 | if (rrc != MATCH_NOMATCH) RRETURN(rrc); | if (rrc != MATCH_NOMATCH) RRETURN(rrc); |
| 4587 | if (fi >= max) | if (fi >= max) MRRETURN(MATCH_NOMATCH); |
| { | ||
| CHECK_PARTIAL(); | ||
| RRETURN(MATCH_NOMATCH); | ||
| } | ||
| 4588 | if (eptr >= md->end_subject) | if (eptr >= md->end_subject) |
| 4589 | { | { |
| 4590 | SCHECK_PARTIAL(); | SCHECK_PARTIAL(); |
| 4591 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4592 | } | } |
| 4593 | if (ctype == OP_ANY && IS_NEWLINE(eptr)) | if (ctype == OP_ANY && IS_NEWLINE(eptr)) |
| 4594 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4595 | c = *eptr++; | c = *eptr++; |
| 4596 | switch(ctype) | switch(ctype) |
| 4597 | { | { |
| # | Line 4045 for (;;) | Line 4603 for (;;) |
| 4603 | case OP_ANYNL: | case OP_ANYNL: |
| 4604 | switch(c) | switch(c) |
| 4605 | { | { |
| 4606 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 4607 | case 0x000d: | case 0x000d: |
| 4608 | if (eptr < md->end_subject && *eptr == 0x0a) eptr++; | if (eptr < md->end_subject && *eptr == 0x0a) eptr++; |
| 4609 | break; | break; |
| # | Line 4056 for (;;) | Line 4614 for (;;) |
| 4614 | case 0x000b: | case 0x000b: |
| 4615 | case 0x000c: | case 0x000c: |
| 4616 | case 0x0085: | case 0x0085: |
| 4617 | if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH); | if (md->bsr_anycrlf) MRRETURN(MATCH_NOMATCH); |
| 4618 | break; | break; |
| 4619 | } | } |
| 4620 | break; | break; |
| # | Line 4068 for (;;) | Line 4626 for (;;) |
| 4626 | case 0x09: /* HT */ | case 0x09: /* HT */ |
| 4627 | case 0x20: /* SPACE */ | case 0x20: /* SPACE */ |
| 4628 | case 0xa0: /* NBSP */ | case 0xa0: /* NBSP */ |
| 4629 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4630 | } | } |
| 4631 | break; | break; |
| 4632 | ||
| 4633 | case OP_HSPACE: | case OP_HSPACE: |
| 4634 | switch(c) | switch(c) |
| 4635 | { | { |
| 4636 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 4637 | case 0x09: /* HT */ | case 0x09: /* HT */ |
| 4638 | case 0x20: /* SPACE */ | case 0x20: /* SPACE */ |
| 4639 | case 0xa0: /* NBSP */ | case 0xa0: /* NBSP */ |
| # | Line 4092 for (;;) | Line 4650 for (;;) |
| 4650 | case 0x0c: /* FF */ | case 0x0c: /* FF */ |
| 4651 | case 0x0d: /* CR */ | case 0x0d: /* CR */ |
| 4652 | case 0x85: /* NEL */ | case 0x85: /* NEL */ |
| 4653 | RRETURN(MATCH_NOMATCH); | MRRETURN(MATCH_NOMATCH); |
| 4654 | } | } |
| 4655 | break; | break; |
| 4656 | ||
| 4657 | case OP_VSPACE: | case OP_VSPACE: |
| 4658 | switch(c) | switch(c) |
| 4659 | { | { |
| 4660 | default: RRETURN(MATCH_NOMATCH); | default: MRRETURN(MATCH_NOMATCH); |
| 4661 | case 0x0a: /* LF */ | case 0x0a: /* LF */ |
| 4662 | case 0x0b: /* VT */ | case 0x0b: /* VT */ |
| 4663 | case 0x0c: /* FF */ | case 0x0c: /* FF */ |
| # | Line 4110 for (;;) | Line 4668 for (;;) |
| 4668 | break; | break; |
| 4669 | ||
| 4670 | case OP_NOT_DIGIT: | case OP_NOT_DIGIT: |
| 4671 | if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH); | if ((md->ctypes[c] & ctype_digit) != 0) MRRETURN(MATCH_NOMATCH); |
| 4672 | break; | break; |
| 4673 | ||
| 4674 | case OP_DIGIT: | case OP_DIGIT: |
| 4675 | if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH); | if ((md->ctypes[c] & ctype_digit) == 0) MRRETURN(MATCH_NOMATCH); |
| 4676 | break; | break; |
| 4677 | ||
| 4678 | case OP_NOT_WHITESPACE: | case OP_NOT_WHITESPACE: |
| 4679 | if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH); | if ((md->ctypes[c] & ctype_space) != 0) MRRETURN(MATCH_NOMATCH); |
| 4680 | break; | break; |
| 4681 | ||
| 4682 | case OP_WHITESPACE: | case OP_WHITESPACE: |
| 4683 | if ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH); | if ((md->ctypes[c] & ctype_space) == 0) MRRETURN(MATCH_NOMATCH); |
| 4684 | break; | break; |
| 4685 | ||
| 4686 | case OP_NOT_WORDCHAR: | case OP_NOT_WORDCHAR: |
| 4687 | if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH); | if ((md->ctypes[c] & ctype_word) != 0) MRRETURN(MATCH_NOMATCH); |
| 4688 | break; | break; |
| 4689 | ||
| 4690 | case OP_WORDCHAR: | case OP_WORDCHAR: |
| 4691 | if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH); | if ((md->ctypes[c] & ctype_word) == 0) MRRETURN(MATCH_NOMATCH); |
| 4692 | break; | break; |
| 4693 | ||
| 4694 | default: | default: |
| # | Line 4158 for (;;) | Line 4716 for (;;) |
| 4716 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 4717 | { | { |
| 4718 | int len = 1; | int len = 1; |
| 4719 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 4720 | GETCHARLEN(c, eptr, len); | { |
| 4721 | SCHECK_PARTIAL(); | |
| 4722 | break; | |
| 4723 | } | |
| 4724 | GETCHARLENTEST(c, eptr, len); | |
| 4725 | if (prop_fail_result) break; | if (prop_fail_result) break; |
| 4726 | eptr+= len; | eptr+= len; |
| 4727 | } | } |
| # | Line 4169 for (;;) | Line 4731 for (;;) |
| 4731 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 4732 | { | { |
| 4733 | int len = 1; | int len = 1; |
| 4734 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 4735 | GETCHARLEN(c, eptr, len); | { |
| 4736 | SCHECK_PARTIAL(); | |
| 4737 | break; | |
| 4738 | } | |
| 4739 | GETCHARLENTEST(c, eptr, len); | |
| 4740 | prop_chartype = UCD_CHARTYPE(c); | prop_chartype = UCD_CHARTYPE(c); |
| 4741 | if ((prop_chartype == ucp_Lu || | if ((prop_chartype == ucp_Lu || |
| 4742 | prop_chartype == ucp_Ll || | prop_chartype == ucp_Ll || |
| # | Line 4184 for (;;) | Line 4750 for (;;) |
| 4750 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 4751 | { | { |
| 4752 | int len = 1; | int len = 1; |
| 4753 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 4754 | GETCHARLEN(c, eptr, len); | { |
| 4755 | SCHECK_PARTIAL(); | |
| 4756 | break; | |
| 4757 | } | |
| 4758 | GETCHARLENTEST(c, eptr, len); | |
| 4759 | prop_category = UCD_CATEGORY(c); | prop_category = UCD_CATEGORY(c); |
| 4760 | if ((prop_category == prop_value) == prop_fail_result) | if ((prop_category == prop_value) == prop_fail_result) |
| 4761 | break; | break; |
| # | Line 4197 for (;;) | Line 4767 for (;;) |
| 4767 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 4768 | { | { |
| 4769 | int len = 1; | int len = 1; |
| 4770 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 4771 | GETCHARLEN(c, eptr, len); | { |
| 4772 | SCHECK_PARTIAL(); | |
| 4773 | break; | |
| 4774 | } | |
| 4775 | GETCHARLENTEST(c, eptr, len); | |
| 4776 | prop_chartype = UCD_CHARTYPE(c); | prop_chartype = UCD_CHARTYPE(c); |
| 4777 | if ((prop_chartype == prop_value) == prop_fail_result) | if ((prop_chartype == prop_value) == prop_fail_result) |
| 4778 | break; | break; |
| # | Line 4210 for (;;) | Line 4784 for (;;) |
| 4784 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 4785 | { | { |
| 4786 | int len = 1; | int len = 1; |
| 4787 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 4788 | GETCHARLEN(c, eptr, len); | { |
| 4789 | SCHECK_PARTIAL(); | |
| 4790 | break; | |
| 4791 | } | |
| 4792 | GETCHARLENTEST(c, eptr, len); | |
| 4793 | prop_script = UCD_SCRIPT(c); | prop_script = UCD_SCRIPT(c); |
| 4794 | if ((prop_script == prop_value) == prop_fail_result) | if ((prop_script == prop_value) == prop_fail_result) |
| 4795 | break; | break; |
| 4796 | eptr+= len; | eptr+= len; |
| 4797 | } | } |
| 4798 | break; | break; |
| 4799 | ||
| 4800 | case PT_ALNUM: | |
| 4801 | for (i = min; i < max; i++) | |
| 4802 | { | |
| 4803 | int len = 1; | |
| 4804 | if (eptr >= md->end_subject) | |
| 4805 | { | |
| 4806 | SCHECK_PARTIAL(); | |
| 4807 | break; | |
| 4808 | } | |
| 4809 | GETCHARLENTEST(c, eptr, len); | |
| 4810 | prop_category = UCD_CATEGORY(c); | |
| 4811 | if ((prop_category == ucp_L || prop_category == ucp_N) | |
| 4812 | == prop_fail_result) | |
| 4813 | break; | |
| 4814 | eptr+= len; | |
| 4815 | } | |
| 4816 | break; | |
| 4817 | ||
| 4818 | case PT_SPACE: /* Perl space */ | |
| 4819 | for (i = min; i < max; i++) | |
| 4820 | { | |
| 4821 | int len = 1; | |
| 4822 | if (eptr >= md->end_subject) | |
| 4823 | { | |
| 4824 | SCHECK_PARTIAL(); | |
| 4825 | break; | |
| 4826 | } | |
| 4827 | GETCHARLENTEST(c, eptr, len); | |
| 4828 | prop_category = UCD_CATEGORY(c); | |
| 4829 | if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL || | |
| 4830 | c == CHAR_FF || c == CHAR_CR) | |
| 4831 | == prop_fail_result) | |
| 4832 | break; | |
| 4833 | eptr+= len; | |
| 4834 | } | |
| 4835 | break; | |
| 4836 | ||
| 4837 | case PT_PXSPACE: /* POSIX space */ | |
| 4838 | for (i = min; i < max; i++) | |
| 4839 | { | |
| 4840 | int len = 1; | |
| 4841 | if (eptr >= md->end_subject) | |
| 4842 | { | |
| 4843 | SCHECK_PARTIAL(); | |
| 4844 | break; | |
| 4845 | } | |
| 4846 | GETCHARLENTEST(c, eptr, len); | |
| 4847 | prop_category = UCD_CATEGORY(c); | |
| 4848 | if ((prop_category == ucp_Z || c == CHAR_HT || c == CHAR_NL || | |
| 4849 | c == CHAR_VT || c == CHAR_FF || c == CHAR_CR) | |
| 4850 | == prop_fail_result) | |
| 4851 | break; | |
| 4852 | eptr+= len; | |
| 4853 | } | |
| 4854 | break; | |
| 4855 | ||
| 4856 | case PT_WORD: | |
| 4857 | for (i = min; i < max; i++) | |
| 4858 | { | |
| 4859 | int len = 1; | |
| 4860 | if (eptr >= md->end_subject) | |
| 4861 | { | |
| 4862 | SCHECK_PARTIAL(); | |
| 4863 | break; | |
| 4864 | } | |
| 4865 | GETCHARLENTEST(c, eptr, len); | |
| 4866 | prop_category = UCD_CATEGORY(c); | |
| 4867 | if ((prop_category == ucp_L || prop_category == ucp_N || | |
| 4868 | c == CHAR_UNDERSCORE) == prop_fail_result) | |
| 4869 | break; | |
| 4870 | eptr+= len; | |
| 4871 | } | |
| 4872 | break; | |
| 4873 | ||
| 4874 | default: | |
| 4875 | RRETURN(PCRE_ERROR_INTERNAL); | |
| 4876 | } | } |
| 4877 | ||
| 4878 | /* eptr is now past the end of the maximum run */ | /* eptr is now past the end of the maximum run */ |
| 4879 | ||
| CHECK_PARTIAL(); | ||
| 4880 | if (possessive) continue; | if (possessive) continue; |
| 4881 | for(;;) | for(;;) |
| 4882 | { | { |
| # | Line 4240 for (;;) | Line 4894 for (;;) |
| 4894 | { | { |
| 4895 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 4896 | { | { |
| 4897 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 4898 | { | |
| 4899 | SCHECK_PARTIAL(); | |
| 4900 | break; | |
| 4901 | } | |
| 4902 | GETCHARINCTEST(c, eptr); | GETCHARINCTEST(c, eptr); |
| 4903 | prop_category = UCD_CATEGORY(c); | prop_category = UCD_CATEGORY(c); |
| 4904 | if (prop_category == ucp_M) break; | if (prop_category == ucp_M) break; |
| # | Line 4259 for (;;) | Line 4917 for (;;) |
| 4917 | ||
| 4918 | /* eptr is now past the end of the maximum run */ | /* eptr is now past the end of the maximum run */ |
| 4919 | ||
| CHECK_PARTIAL(); | ||
| 4920 | if (possessive) continue; | if (possessive) continue; |
| 4921 | ||
| 4922 | for(;;) | for(;;) |
| 4923 | { | { |
| 4924 | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45); | RMATCH(eptr, ecode, offset_top, md, ims, eptrb, 0, RM45); |
| # | Line 4296 for (;;) | Line 4954 for (;;) |
| 4954 | { | { |
| 4955 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 4956 | { | { |
| 4957 | if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break; | if (eptr >= md->end_subject) |
| 4958 | { | |
| 4959 | SCHECK_PARTIAL(); | |
| 4960 | break; | |
| 4961 | } | |
| 4962 | if (IS_NEWLINE(eptr)) break; | |
| 4963 | eptr++; | eptr++; |
| 4964 | while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; | while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; |
| 4965 | } | } |
| # | Line 4308 for (;;) | Line 4971 for (;;) |
| 4971 | { | { |
| 4972 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 4973 | { | { |
| 4974 | if (eptr >= md->end_subject || IS_NEWLINE(eptr)) break; | if (eptr >= md->end_subject) |
| 4975 | { | |
| 4976 | SCHECK_PARTIAL(); | |
| 4977 | break; | |
| 4978 | } | |
| 4979 | if (IS_NEWLINE(eptr)) break; | |
| 4980 | eptr++; | eptr++; |
| 4981 | while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; | while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; |
| 4982 | } | } |
| # | Line 4320 for (;;) | Line 4988 for (;;) |
| 4988 | { | { |
| 4989 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 4990 | { | { |
| 4991 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 4992 | { | |
| 4993 | SCHECK_PARTIAL(); | |
| 4994 | break; | |
| 4995 | } | |
| 4996 | eptr++; | eptr++; |
| 4997 | while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; | while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++; |
| 4998 | } | } |
| # | Line 4333 for (;;) | Line 5005 for (;;) |
| 5005 | case OP_ANYBYTE: | case OP_ANYBYTE: |
| 5006 | c = max - min; | c = max - min; |
| 5007 | if (c > (unsigned int)(md->end_subject - eptr)) | if (c > (unsigned int)(md->end_subject - eptr)) |
| 5008 | c = md->end_subject - eptr; | { |
| 5009 | eptr += c; | eptr = md->end_subject; |
| 5010 | SCHECK_PARTIAL(); | |
| 5011 | } | |
| 5012 | else eptr += c; | |
| 5013 | break; | break; |
| 5014 | ||
| 5015 | case OP_ANYNL: | case OP_ANYNL: |
| 5016 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 5017 | { | { |
| 5018 | int len = 1; | int len = 1; |
| 5019 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 5020 | { | |
| 5021 | SCHECK_PARTIAL(); | |
| 5022 | break; | |
| 5023 | } | |
| 5024 | GETCHARLEN(c, eptr, len); | GETCHARLEN(c, eptr, len); |
| 5025 | if (c == 0x000d) | if (c == 0x000d) |
| 5026 | { | { |
| # | Line 4366 for (;;) | Line 5045 for (;;) |
| 5045 | { | { |
| 5046 | BOOL gotspace; | BOOL gotspace; |
| 5047 | int len = 1; | int len = 1; |
| 5048 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 5049 | { | |
| 5050 | SCHECK_PARTIAL(); | |
| 5051 | break; | |
| 5052 | } | |
| 5053 | GETCHARLEN(c, eptr, len); | GETCHARLEN(c, eptr, len); |
| 5054 | switch(c) | switch(c) |
| 5055 | { | { |
| # | Line 4404 for (;;) | Line 5087 for (;;) |
| 5087 | { | { |
| 5088 | BOOL gotspace; | BOOL gotspace; |
| 5089 | int len = 1; | int len = 1; |
| 5090 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 5091 | { | |
| 5092 | SCHECK_PARTIAL(); | |
| 5093 | break; | |
| 5094 | } | |
| 5095 | GETCHARLEN(c, eptr, len); | GETCHARLEN(c, eptr, len); |
| 5096 | switch(c) | switch(c) |
| 5097 | { | { |
| # | Line 4428 for (;;) | Line 5115 for (;;) |
| 5115 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 5116 | { | { |
| 5117 | int len = 1; | int len = 1; |
| 5118 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 5119 | { | |
| 5120 | SCHECK_PARTIAL(); | |
| 5121 | break; | |
| 5122 | } | |
| 5123 | GETCHARLEN(c, eptr, len); | GETCHARLEN(c, eptr, len); |
| 5124 | if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break; | if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break; |
| 5125 | eptr+= len; | eptr+= len; |
| # | Line 4439 for (;;) | Line 5130 for (;;) |
| 5130 | for (i = min; i < max; i++) | for (i = min; i < max; i++) |
| 5131 | { | { |
| 5132 | int len = 1; | int len = 1; |
| 5133 | if (eptr >= md->end_subject) break; | if (eptr >= md->end_subject) |
| 5134 | { | |
| 5135 |