Changeset 27829 in webkit for trunk/JavaScriptCore/pcre/pcre_exec.cpp
- Timestamp:
- Nov 15, 2007, 4:16:21 PM (18 years ago)
- File:
-
- 1 edited
-
trunk/JavaScriptCore/pcre/pcre_exec.cpp (modified) (92 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/JavaScriptCore/pcre/pcre_exec.cpp
r27828 r27829 266 266 267 267 #define RMATCH_WHERE(num) &&RRETURN_##num 268 #define RRETURN_LABEL * frame->where268 #define RRETURN_LABEL *stack.currentFrame->where 269 269 270 270 #endif … … 272 272 #define RMATCH(num, ra, rb, rc)\ 273 273 {\ 274 if ( frame >= stackframes && frame + 1 < stackframesend)\275 newframe = frame + 1;\274 if (stack.currentFrame >= stack.frames && stack.currentFrame + 1 < stack.framesEnd)\ 275 newframe = stack.currentFrame + 1;\ 276 276 else\ 277 277 newframe = new matchframe;\ 278 newframe->eptr = frame->eptr;\278 newframe->eptr = stack.currentFrame->eptr;\ 279 279 newframe->ecode = (ra);\ 280 newframe->offset_top = frame->offset_top;\280 newframe->offset_top = stack.currentFrame->offset_top;\ 281 281 newframe->eptrb = (rb);\ 282 282 is_group_start = (rc);\ 283 283 ++rdepth;\ 284 newframe->prevframe = frame;\285 frame = newframe;\286 frame->where = RMATCH_WHERE(num);\284 newframe->prevframe = stack.currentFrame;\ 285 stack.currentFrame = newframe;\ 286 stack.currentFrame->where = RMATCH_WHERE(num);\ 287 287 DPRINTF(("restarting from line %d\n", __LINE__));\ 288 288 goto RECURSE;\ 289 289 RRETURN_##num:\ 290 newframe = frame;\291 frame = frame->prevframe;\292 if (!(newframe >= stack frames && newframe < stackframesend))\290 newframe = stack.currentFrame;\ 291 stack.currentFrame = stack.currentFrame->prevframe;\ 292 if (!(newframe >= stack.frames && newframe < stack.framesEnd))\ 293 293 delete newframe;\ 294 294 --rdepth;\ … … 305 305 306 306 #define RRETURN_ERROR(error) \ 307 { \ 308 i = (error); \ 309 goto RETURN_ERROR; \ 310 } 307 return matchError(error, stack); 311 308 312 309 /************************************************* … … 332 329 (e.g. stopped by repeated call or recursion limit) 333 330 */ 331 332 struct MatchStack { 333 MatchStack() 334 { 335 framesEnd = frames + sizeof(frames) / sizeof(frames[0]); 336 currentFrame = frames; 337 } 338 matchframe frames[16]; 339 matchframe* framesEnd; 340 matchframe* currentFrame; 341 342 void unrollAnyHeapAllocatedFrames() 343 { 344 while (!(currentFrame >= frames && currentFrame < framesEnd)) { 345 matchframe* parentFrame = currentFrame->prevframe; 346 delete currentFrame; 347 currentFrame = parentFrame; 348 } 349 } 350 }; 351 352 static int matchError(int errorCode, MatchStack& stack) 353 { 354 stack.unrollAnyHeapAllocatedFrames(); 355 return errorCode; 356 } 334 357 335 358 static int match(USPTR eptr, const uschar* ecode, int offset_top, match_data* md) … … 350 373 any calls to pcre_stack_malloc, yet the amount of stack used for the array is 351 374 modest enough that we don't run out of stack. */ 352 matchframe stackframes[16]; 353 matchframe *stackframesend = stackframes + sizeof(stackframes) / sizeof(stackframes[0]); 354 355 matchframe *frame = stackframes; 356 matchframe *newframe; 375 MatchStack stack; 376 matchframe* newframe; 357 377 358 378 /* The opcode jump table. */ … … 371 391 372 392 #ifdef USE_COMPUTED_GOTO_FOR_MATCH_RECURSION 373 frame->where = &&RETURN;393 stack.currentFrame->where = &&RETURN; 374 394 #else 375 frame->where = 0;395 stack.currentFrame->where = 0; 376 396 #endif 377 397 378 frame->eptr = eptr;379 frame->ecode = ecode;380 frame->offset_top = offset_top;381 frame->eptrb = NULL;398 stack.currentFrame->eptr = eptr; 399 stack.currentFrame->ecode = ecode; 400 stack.currentFrame->offset_top = offset_top; 401 stack.currentFrame->eptrb = NULL; 382 402 383 403 /* This is where control jumps back to to effect "recursion" */ … … 407 427 408 428 if (is_group_start) { 409 frame->newptrb.epb_prev = frame->eptrb;410 frame->newptrb.epb_saved_eptr = frame->eptr;411 frame->eptrb = &frame->newptrb;429 stack.currentFrame->newptrb.epb_prev = stack.currentFrame->eptrb; 430 stack.currentFrame->newptrb.epb_saved_eptr = stack.currentFrame->eptr; 431 stack.currentFrame->eptrb = &stack.currentFrame->newptrb; 412 432 } 413 433 … … 421 441 #ifdef USE_COMPUTED_GOTO_FOR_MATCH_OPCODE_LOOP 422 442 #define BEGIN_OPCODE(opcode) LABEL_OP_##opcode 423 #define NEXT_OPCODE goto *opcode_jump_table[* frame->ecode]443 #define NEXT_OPCODE goto *opcode_jump_table[*stack.currentFrame->ecode] 424 444 #else 425 445 #define BEGIN_OPCODE(opcode) case OP_##opcode … … 430 450 NEXT_OPCODE; 431 451 #else 432 switch (* frame->ecode)452 switch (*stack.currentFrame->ecode) 433 453 #endif 434 454 { … … 439 459 DPRINTF(("start bracket 0\n")); 440 460 do { 441 RMATCH(2, frame->ecode + 1 + LINK_SIZE, frame->eptrb, match_isgroup);461 RMATCH(2, stack.currentFrame->ecode + 1 + LINK_SIZE, stack.currentFrame->eptrb, match_isgroup); 442 462 if (is_match) 443 463 RRETURN; 444 frame->ecode += GET(frame->ecode, 1);445 } while (* frame->ecode == OP_ALT);464 stack.currentFrame->ecode += GET(stack.currentFrame->ecode, 1); 465 } while (*stack.currentFrame->ecode == OP_ALT); 446 466 DPRINTF(("bracket 0 failed\n")); 447 467 RRETURN; … … 450 470 451 471 BEGIN_OPCODE(BRANUMBER): 452 frame->ecode += 3;472 stack.currentFrame->ecode += 3; 453 473 NEXT_OPCODE; 454 474 … … 456 476 457 477 BEGIN_OPCODE(END): 458 md->end_match_ptr = frame->eptr; /* Record where we ended */459 md->end_offset_top = frame->offset_top; /* and how many extracts were taken */478 md->end_match_ptr = stack.currentFrame->eptr; /* Record where we ended */ 479 md->end_offset_top = stack.currentFrame->offset_top; /* and how many extracts were taken */ 460 480 is_match = true; 461 481 RRETURN; … … 469 489 BEGIN_OPCODE(ASSERT): 470 490 do { 471 RMATCH(6, frame->ecode + 1 + LINK_SIZE, NULL, match_isgroup);491 RMATCH(6, stack.currentFrame->ecode + 1 + LINK_SIZE, NULL, match_isgroup); 472 492 if (is_match) break; 473 frame->ecode += GET(frame->ecode, 1);474 } while (* frame->ecode == OP_ALT);475 if (* frame->ecode == OP_KET)493 stack.currentFrame->ecode += GET(stack.currentFrame->ecode, 1); 494 } while (*stack.currentFrame->ecode == OP_ALT); 495 if (*stack.currentFrame->ecode == OP_KET) 476 496 RRETURN_NO_MATCH; 477 497 … … 479 499 mark, since extracts may have been taken during the assertion. */ 480 500 481 do frame->ecode += GET(frame->ecode,1); while (*frame->ecode == OP_ALT);482 frame->ecode += 1 + LINK_SIZE;483 frame->offset_top = md->end_offset_top;501 do stack.currentFrame->ecode += GET(stack.currentFrame->ecode,1); while (*stack.currentFrame->ecode == OP_ALT); 502 stack.currentFrame->ecode += 1 + LINK_SIZE; 503 stack.currentFrame->offset_top = md->end_offset_top; 484 504 NEXT_OPCODE; 485 505 … … 488 508 BEGIN_OPCODE(ASSERT_NOT): 489 509 do { 490 RMATCH(7, frame->ecode + 1 + LINK_SIZE, NULL, match_isgroup);510 RMATCH(7, stack.currentFrame->ecode + 1 + LINK_SIZE, NULL, match_isgroup); 491 511 if (is_match) 492 512 RRETURN_NO_MATCH; 493 frame->ecode += GET(frame->ecode,1);494 } while (* frame->ecode == OP_ALT);495 496 frame->ecode += 1 + LINK_SIZE;513 stack.currentFrame->ecode += GET(stack.currentFrame->ecode,1); 514 } while (*stack.currentFrame->ecode == OP_ALT); 515 516 stack.currentFrame->ecode += 1 + LINK_SIZE; 497 517 NEXT_OPCODE; 498 518 … … 505 525 506 526 BEGIN_OPCODE(ONCE): 507 frame->prev = frame->ecode;508 frame->saved_eptr = frame->eptr;527 stack.currentFrame->prev = stack.currentFrame->ecode; 528 stack.currentFrame->saved_eptr = stack.currentFrame->eptr; 509 529 510 530 do { 511 RMATCH(9, frame->ecode + 1 + LINK_SIZE, frame->eptrb, match_isgroup);531 RMATCH(9, stack.currentFrame->ecode + 1 + LINK_SIZE, stack.currentFrame->eptrb, match_isgroup); 512 532 if (is_match) 513 533 break; 514 frame->ecode += GET(frame->ecode,1);515 } while (* frame->ecode == OP_ALT);534 stack.currentFrame->ecode += GET(stack.currentFrame->ecode,1); 535 } while (*stack.currentFrame->ecode == OP_ALT); 516 536 517 537 /* If hit the end of the group (which could be repeated), fail */ 518 538 519 if (* frame->ecode != OP_ONCE && *frame->ecode != OP_ALT)539 if (*stack.currentFrame->ecode != OP_ONCE && *stack.currentFrame->ecode != OP_ALT) 520 540 RRETURN; 521 541 … … 523 543 mark, since extracts may have been taken. */ 524 544 525 do frame->ecode += GET(frame->ecode,1); while (*frame->ecode == OP_ALT);526 527 frame->offset_top = md->end_offset_top;528 frame->eptr = md->end_match_ptr;545 do stack.currentFrame->ecode += GET(stack.currentFrame->ecode,1); while (*stack.currentFrame->ecode == OP_ALT); 546 547 stack.currentFrame->offset_top = md->end_offset_top; 548 stack.currentFrame->eptr = md->end_match_ptr; 529 549 530 550 /* For a non-repeating ket, just continue at this level. This also … … 534 554 course of events. */ 535 555 536 if (* frame->ecode == OP_KET || frame->eptr == frame->saved_eptr) {537 frame->ecode += 1+LINK_SIZE;556 if (*stack.currentFrame->ecode == OP_KET || stack.currentFrame->eptr == stack.currentFrame->saved_eptr) { 557 stack.currentFrame->ecode += 1+LINK_SIZE; 538 558 NEXT_OPCODE; 539 559 } … … 544 564 opcode. */ 545 565 546 if (* frame->ecode == OP_KETRMIN) {547 RMATCH(10, frame->ecode + 1 + LINK_SIZE, frame->eptrb, 0);566 if (*stack.currentFrame->ecode == OP_KETRMIN) { 567 RMATCH(10, stack.currentFrame->ecode + 1 + LINK_SIZE, stack.currentFrame->eptrb, 0); 548 568 if (is_match) 549 569 RRETURN; 550 RMATCH(11, frame->prev, frame->eptrb, match_isgroup);570 RMATCH(11, stack.currentFrame->prev, stack.currentFrame->eptrb, match_isgroup); 551 571 if (is_match) 552 572 RRETURN; 553 573 } else { /* OP_KETRMAX */ 554 RMATCH(12, frame->prev, frame->eptrb, match_isgroup);574 RMATCH(12, stack.currentFrame->prev, stack.currentFrame->eptrb, match_isgroup); 555 575 if (is_match) 556 576 RRETURN; 557 RMATCH(13, frame->ecode + 1+LINK_SIZE, frame->eptrb, 0);577 RMATCH(13, stack.currentFrame->ecode + 1+LINK_SIZE, stack.currentFrame->eptrb, 0); 558 578 if (is_match) 559 579 RRETURN; … … 565 585 566 586 BEGIN_OPCODE(ALT): 567 do frame->ecode += GET(frame->ecode,1); while (*frame->ecode == OP_ALT);587 do stack.currentFrame->ecode += GET(stack.currentFrame->ecode,1); while (*stack.currentFrame->ecode == OP_ALT); 568 588 NEXT_OPCODE; 569 589 … … 576 596 BEGIN_OPCODE(BRAZERO): 577 597 { 578 frame->next = frame->ecode+1;579 RMATCH(14, frame->next, frame->eptrb, match_isgroup);598 stack.currentFrame->next = stack.currentFrame->ecode+1; 599 RMATCH(14, stack.currentFrame->next, stack.currentFrame->eptrb, match_isgroup); 580 600 if (is_match) 581 601 RRETURN; 582 do frame->next += GET(frame->next,1); while (*frame->next == OP_ALT);583 frame->ecode = frame->next + 1+LINK_SIZE;602 do stack.currentFrame->next += GET(stack.currentFrame->next,1); while (*stack.currentFrame->next == OP_ALT); 603 stack.currentFrame->ecode = stack.currentFrame->next + 1+LINK_SIZE; 584 604 } 585 605 NEXT_OPCODE; … … 587 607 BEGIN_OPCODE(BRAMINZERO): 588 608 { 589 frame->next = frame->ecode+1;590 do frame->next += GET(frame->next,1); while (*frame->next == OP_ALT);591 RMATCH(15, frame->next + 1+LINK_SIZE, frame->eptrb, match_isgroup);609 stack.currentFrame->next = stack.currentFrame->ecode+1; 610 do stack.currentFrame->next += GET(stack.currentFrame->next,1); while (*stack.currentFrame->next == OP_ALT); 611 RMATCH(15, stack.currentFrame->next + 1+LINK_SIZE, stack.currentFrame->eptrb, match_isgroup); 592 612 if (is_match) 593 613 RRETURN; 594 frame->ecode++;614 stack.currentFrame->ecode++; 595 615 } 596 616 NEXT_OPCODE; … … 604 624 BEGIN_OPCODE(KETRMIN): 605 625 BEGIN_OPCODE(KETRMAX): 606 frame->prev = frame->ecode - GET(frame->ecode, 1);607 frame->saved_eptr = frame->eptrb->epb_saved_eptr;626 stack.currentFrame->prev = stack.currentFrame->ecode - GET(stack.currentFrame->ecode, 1); 627 stack.currentFrame->saved_eptr = stack.currentFrame->eptrb->epb_saved_eptr; 608 628 609 629 /* Back up the stack of bracket start pointers. */ 610 630 611 frame->eptrb = frame->eptrb->epb_prev;612 613 if (* frame->prev == OP_ASSERT || *frame->prev == OP_ASSERT_NOT || *frame->prev == OP_ONCE) {614 md->end_match_ptr = frame->eptr; /* For ONCE */615 md->end_offset_top = frame->offset_top;631 stack.currentFrame->eptrb = stack.currentFrame->eptrb->epb_prev; 632 633 if (*stack.currentFrame->prev == OP_ASSERT || *stack.currentFrame->prev == OP_ASSERT_NOT || *stack.currentFrame->prev == OP_ONCE) { 634 md->end_match_ptr = stack.currentFrame->eptr; /* For ONCE */ 635 md->end_offset_top = stack.currentFrame->offset_top; 616 636 is_match = true; 617 637 RRETURN; … … 622 642 extraction by setting the offsets and bumping the high water mark. */ 623 643 624 frame->number = *frame->prev - OP_BRA;644 stack.currentFrame->number = *stack.currentFrame->prev - OP_BRA; 625 645 626 646 /* For extended extraction brackets (large number), we have to fish out 627 647 the number from a dummy opcode at the start. */ 628 648 629 if ( frame->number > EXTRACT_BASIC_MAX)630 frame->number = GET2(frame->prev, 2+LINK_SIZE);631 frame->offset = frame->number << 1;649 if (stack.currentFrame->number > EXTRACT_BASIC_MAX) 650 stack.currentFrame->number = GET2(stack.currentFrame->prev, 2+LINK_SIZE); 651 stack.currentFrame->offset = stack.currentFrame->number << 1; 632 652 633 653 #ifdef DEBUG 634 printf("end bracket %d", frame->number);654 printf("end bracket %d", stack.currentFrame->number); 635 655 printf("\n"); 636 656 #endif … … 641 661 the OP_END is reached. */ 642 662 643 if ( frame->number > 0) {644 if ( frame->offset >= md->offset_max)663 if (stack.currentFrame->number > 0) { 664 if (stack.currentFrame->offset >= md->offset_max) 645 665 md->offset_overflow = true; 646 666 else { 647 md->offset_vector[ frame->offset] =648 md->offset_vector[md->offset_end - frame->number];649 md->offset_vector[ frame->offset+1] = frame->eptr - md->start_subject;650 if ( frame->offset_top <= frame->offset)651 frame->offset_top = frame->offset + 2;667 md->offset_vector[stack.currentFrame->offset] = 668 md->offset_vector[md->offset_end - stack.currentFrame->number]; 669 md->offset_vector[stack.currentFrame->offset+1] = stack.currentFrame->eptr - md->start_subject; 670 if (stack.currentFrame->offset_top <= stack.currentFrame->offset) 671 stack.currentFrame->offset_top = stack.currentFrame->offset + 2; 652 672 } 653 673 } … … 659 679 course of events. */ 660 680 661 if (* frame->ecode == OP_KET || frame->eptr == frame->saved_eptr) {662 frame->ecode += 1 + LINK_SIZE;681 if (*stack.currentFrame->ecode == OP_KET || stack.currentFrame->eptr == stack.currentFrame->saved_eptr) { 682 stack.currentFrame->ecode += 1 + LINK_SIZE; 663 683 NEXT_OPCODE; 664 684 } … … 667 687 preceding bracket, in the appropriate order. */ 668 688 669 if (* frame->ecode == OP_KETRMIN) {670 RMATCH(16, frame->ecode + 1+LINK_SIZE, frame->eptrb, 0);689 if (*stack.currentFrame->ecode == OP_KETRMIN) { 690 RMATCH(16, stack.currentFrame->ecode + 1+LINK_SIZE, stack.currentFrame->eptrb, 0); 671 691 if (is_match) 672 692 RRETURN; 673 RMATCH(17, frame->prev, frame->eptrb, match_isgroup);693 RMATCH(17, stack.currentFrame->prev, stack.currentFrame->eptrb, match_isgroup); 674 694 if (is_match) 675 695 RRETURN; 676 696 } else { /* OP_KETRMAX */ 677 RMATCH(18, frame->prev, frame->eptrb, match_isgroup);697 RMATCH(18, stack.currentFrame->prev, stack.currentFrame->eptrb, match_isgroup); 678 698 if (is_match) 679 699 RRETURN; 680 RMATCH(19, frame->ecode + 1+LINK_SIZE, frame->eptrb, 0);700 RMATCH(19, stack.currentFrame->ecode + 1+LINK_SIZE, stack.currentFrame->eptrb, 0); 681 701 if (is_match) 682 702 RRETURN; … … 687 707 688 708 BEGIN_OPCODE(CIRC): 689 if ( frame->eptr != md->start_subject && (!md->multiline || !isNewline(frame->eptr[-1])))690 RRETURN_NO_MATCH; 691 frame->ecode++;709 if (stack.currentFrame->eptr != md->start_subject && (!md->multiline || !isNewline(stack.currentFrame->eptr[-1]))) 710 RRETURN_NO_MATCH; 711 stack.currentFrame->ecode++; 692 712 NEXT_OPCODE; 693 713 … … 695 715 696 716 BEGIN_OPCODE(DOLL): 697 if ( frame->eptr < md->end_subject && (!md->multiline || !isNewline(*frame->eptr)))698 RRETURN_NO_MATCH; 699 frame->ecode++;717 if (stack.currentFrame->eptr < md->end_subject && (!md->multiline || !isNewline(*stack.currentFrame->eptr))) 718 RRETURN_NO_MATCH; 719 stack.currentFrame->ecode++; 700 720 NEXT_OPCODE; 701 721 … … 708 728 be "non-word" characters. */ 709 729 710 if ( frame->eptr == md->start_subject)730 if (stack.currentFrame->eptr == md->start_subject) 711 731 prev_is_word = false; 712 732 else { 713 const pcre_uchar *lastptr = frame->eptr - 1;733 const pcre_uchar *lastptr = stack.currentFrame->eptr - 1; 714 734 while(ISMIDCHAR(*lastptr)) 715 735 lastptr--; … … 717 737 prev_is_word = c < 128 && (md->ctypes[c] & ctype_word) != 0; 718 738 } 719 if ( frame->eptr >= md->end_subject)739 if (stack.currentFrame->eptr >= md->end_subject) 720 740 cur_is_word = false; 721 741 else { 722 GETCHAR(c, frame->eptr);742 GETCHAR(c, stack.currentFrame->eptr); 723 743 cur_is_word = c < 128 && (md->ctypes[c] & ctype_word) != 0; 724 744 } … … 726 746 /* Now see if the situation is what we want */ 727 747 728 if ((* frame->ecode++ == OP_WORD_BOUNDARY) ? cur_is_word == prev_is_word : cur_is_word != prev_is_word)748 if ((*stack.currentFrame->ecode++ == OP_WORD_BOUNDARY) ? cur_is_word == prev_is_word : cur_is_word != prev_is_word) 729 749 RRETURN_NO_MATCH; 730 750 NEXT_OPCODE; … … 733 753 734 754 BEGIN_OPCODE(ANY): 735 if ( frame->eptr < md->end_subject && isNewline(*frame->eptr))736 RRETURN_NO_MATCH; 737 if ( frame->eptr++ >= md->end_subject)738 RRETURN_NO_MATCH; 739 while ( frame->eptr < md->end_subject && ISMIDCHAR(*frame->eptr))740 frame->eptr++;741 frame->ecode++;755 if (stack.currentFrame->eptr < md->end_subject && isNewline(*stack.currentFrame->eptr)) 756 RRETURN_NO_MATCH; 757 if (stack.currentFrame->eptr++ >= md->end_subject) 758 RRETURN_NO_MATCH; 759 while (stack.currentFrame->eptr < md->end_subject && ISMIDCHAR(*stack.currentFrame->eptr)) 760 stack.currentFrame->eptr++; 761 stack.currentFrame->ecode++; 742 762 NEXT_OPCODE; 743 763 744 764 BEGIN_OPCODE(NOT_DIGIT): 745 if ( frame->eptr >= md->end_subject)746 RRETURN_NO_MATCH; 747 GETCHARINCTEST(c, frame->eptr);765 if (stack.currentFrame->eptr >= md->end_subject) 766 RRETURN_NO_MATCH; 767 GETCHARINCTEST(c, stack.currentFrame->eptr); 748 768 if (isASCIIDigit(c)) 749 769 RRETURN_NO_MATCH; 750 frame->ecode++;770 stack.currentFrame->ecode++; 751 771 NEXT_OPCODE; 752 772 753 773 BEGIN_OPCODE(DIGIT): 754 if ( frame->eptr >= md->end_subject)755 RRETURN_NO_MATCH; 756 GETCHARINCTEST(c, frame->eptr);774 if (stack.currentFrame->eptr >= md->end_subject) 775 RRETURN_NO_MATCH; 776 GETCHARINCTEST(c, stack.currentFrame->eptr); 757 777 if (!isASCIIDigit(c)) 758 778 RRETURN_NO_MATCH; 759 frame->ecode++;779 stack.currentFrame->ecode++; 760 780 NEXT_OPCODE; 761 781 762 782 BEGIN_OPCODE(NOT_WHITESPACE): 763 if ( frame->eptr >= md->end_subject)764 RRETURN_NO_MATCH; 765 GETCHARINCTEST(c, frame->eptr);783 if (stack.currentFrame->eptr >= md->end_subject) 784 RRETURN_NO_MATCH; 785 GETCHARINCTEST(c, stack.currentFrame->eptr); 766 786 if (c < 128 && (md->ctypes[c] & ctype_space)) 767 787 RRETURN_NO_MATCH; 768 frame->ecode++;788 stack.currentFrame->ecode++; 769 789 NEXT_OPCODE; 770 790 771 791 BEGIN_OPCODE(WHITESPACE): 772 if ( frame->eptr >= md->end_subject)773 RRETURN_NO_MATCH; 774 GETCHARINCTEST(c, frame->eptr);792 if (stack.currentFrame->eptr >= md->end_subject) 793 RRETURN_NO_MATCH; 794 GETCHARINCTEST(c, stack.currentFrame->eptr); 775 795 if (c >= 128 || !(md->ctypes[c] & ctype_space)) 776 796 RRETURN_NO_MATCH; 777 frame->ecode++;797 stack.currentFrame->ecode++; 778 798 NEXT_OPCODE; 779 799 780 800 BEGIN_OPCODE(NOT_WORDCHAR): 781 if ( frame->eptr >= md->end_subject)782 RRETURN_NO_MATCH; 783 GETCHARINCTEST(c, frame->eptr);801 if (stack.currentFrame->eptr >= md->end_subject) 802 RRETURN_NO_MATCH; 803 GETCHARINCTEST(c, stack.currentFrame->eptr); 784 804 if (c < 128 && (md->ctypes[c] & ctype_word)) 785 805 RRETURN_NO_MATCH; 786 frame->ecode++;806 stack.currentFrame->ecode++; 787 807 NEXT_OPCODE; 788 808 789 809 BEGIN_OPCODE(WORDCHAR): 790 if ( frame->eptr >= md->end_subject)791 RRETURN_NO_MATCH; 792 GETCHARINCTEST(c, frame->eptr);810 if (stack.currentFrame->eptr >= md->end_subject) 811 RRETURN_NO_MATCH; 812 GETCHARINCTEST(c, stack.currentFrame->eptr); 793 813 if (c >= 128 || !(md->ctypes[c] & ctype_word)) 794 814 RRETURN_NO_MATCH; 795 frame->ecode++;815 stack.currentFrame->ecode++; 796 816 NEXT_OPCODE; 797 817 … … 805 825 806 826 BEGIN_OPCODE(REF): 807 frame->offset = GET2(frame->ecode, 1) << 1; /* Doubled ref number */808 frame->ecode += 3; /* Advance past item */827 stack.currentFrame->offset = GET2(stack.currentFrame->ecode, 1) << 1; /* Doubled ref number */ 828 stack.currentFrame->ecode += 3; /* Advance past item */ 809 829 810 830 /* If the reference is unset, set the length to be longer than the amount … … 813 833 minima. */ 814 834 815 if ( frame->offset >= frame->offset_top || md->offset_vector[frame->offset] < 0)816 frame->length = 0;835 if (stack.currentFrame->offset >= stack.currentFrame->offset_top || md->offset_vector[stack.currentFrame->offset] < 0) 836 stack.currentFrame->length = 0; 817 837 else 818 frame->length = md->offset_vector[frame->offset+1] - md->offset_vector[frame->offset];838 stack.currentFrame->length = md->offset_vector[stack.currentFrame->offset+1] - md->offset_vector[stack.currentFrame->offset]; 819 839 820 840 /* Set up for repetition, or handle the non-repeated case */ 821 841 822 switch (* frame->ecode) {842 switch (*stack.currentFrame->ecode) { 823 843 case OP_CRSTAR: 824 844 case OP_CRMINSTAR: … … 827 847 case OP_CRQUERY: 828 848 case OP_CRMINQUERY: 829 c = * frame->ecode++ - OP_CRSTAR;849 c = *stack.currentFrame->ecode++ - OP_CRSTAR; 830 850 minimize = (c & 1) != 0; 831 851 min = rep_min[c]; /* Pick up values from tables; */ 832 frame->max = rep_max[c]; /* zero for max => infinity */833 if ( frame->max == 0)834 frame->max = INT_MAX;852 stack.currentFrame->max = rep_max[c]; /* zero for max => infinity */ 853 if (stack.currentFrame->max == 0) 854 stack.currentFrame->max = INT_MAX; 835 855 break; 836 856 837 857 case OP_CRRANGE: 838 858 case OP_CRMINRANGE: 839 minimize = (* frame->ecode == OP_CRMINRANGE);840 min = GET2( frame->ecode, 1);841 frame->max = GET2(frame->ecode, 3);842 if ( frame->max == 0)843 frame->max = INT_MAX;844 frame->ecode += 5;859 minimize = (*stack.currentFrame->ecode == OP_CRMINRANGE); 860 min = GET2(stack.currentFrame->ecode, 1); 861 stack.currentFrame->max = GET2(stack.currentFrame->ecode, 3); 862 if (stack.currentFrame->max == 0) 863 stack.currentFrame->max = INT_MAX; 864 stack.currentFrame->ecode += 5; 845 865 break; 846 866 847 867 default: /* No repeat follows */ 848 if (!match_ref( frame->offset, frame->eptr, frame->length, md))868 if (!match_ref(stack.currentFrame->offset, stack.currentFrame->eptr, stack.currentFrame->length, md)) 849 869 RRETURN_NO_MATCH; 850 frame->eptr += frame->length;870 stack.currentFrame->eptr += stack.currentFrame->length; 851 871 NEXT_OPCODE; 852 872 } … … 855 875 main loop. */ 856 876 857 if ( frame->length == 0)877 if (stack.currentFrame->length == 0) 858 878 NEXT_OPCODE; 859 879 … … 861 881 862 882 for (i = 1; i <= min; i++) { 863 if (!match_ref( frame->offset, frame->eptr, frame->length, md))883 if (!match_ref(stack.currentFrame->offset, stack.currentFrame->eptr, stack.currentFrame->length, md)) 864 884 RRETURN_NO_MATCH; 865 frame->eptr += frame->length;885 stack.currentFrame->eptr += stack.currentFrame->length; 866 886 } 867 887 … … 869 889 They are not both allowed to be zero. */ 870 890 871 if (min == frame->max)891 if (min == stack.currentFrame->max) 872 892 NEXT_OPCODE; 873 893 … … 875 895 876 896 if (minimize) { 877 for ( frame->fi = min;; frame->fi++) {878 RMATCH(20, frame->ecode, frame->eptrb, 0);897 for (stack.currentFrame->fi = min;; stack.currentFrame->fi++) { 898 RMATCH(20, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 879 899 if (is_match) 880 900 RRETURN; 881 if ( frame->fi >= frame->max || !match_ref(frame->offset, frame->eptr, frame->length, md))901 if (stack.currentFrame->fi >= stack.currentFrame->max || !match_ref(stack.currentFrame->offset, stack.currentFrame->eptr, stack.currentFrame->length, md)) 882 902 RRETURN; 883 frame->eptr += frame->length;903 stack.currentFrame->eptr += stack.currentFrame->length; 884 904 } 885 905 ASSERT_NOT_REACHED(); … … 889 909 890 910 else { 891 frame->pp = frame->eptr;892 for (i = min; i < frame->max; i++) {893 if (!match_ref( frame->offset, frame->eptr, frame->length, md))894 break; 895 frame->eptr += frame->length;911 stack.currentFrame->pp = stack.currentFrame->eptr; 912 for (i = min; i < stack.currentFrame->max; i++) { 913 if (!match_ref(stack.currentFrame->offset, stack.currentFrame->eptr, stack.currentFrame->length, md)) 914 break; 915 stack.currentFrame->eptr += stack.currentFrame->length; 896 916 } 897 while ( frame->eptr >= frame->pp) {898 RMATCH(21, frame->ecode, frame->eptrb, 0);917 while (stack.currentFrame->eptr >= stack.currentFrame->pp) { 918 RMATCH(21, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 899 919 if (is_match) 900 920 RRETURN; 901 frame->eptr -= frame->length;921 stack.currentFrame->eptr -= stack.currentFrame->length; 902 922 } 903 923 RRETURN_NO_MATCH; … … 918 938 BEGIN_OPCODE(NCLASS): 919 939 BEGIN_OPCODE(CLASS): 920 frame->data = frame->ecode + 1; /* Save for matching */921 frame->ecode += 33; /* Advance past the item */922 923 switch (* frame->ecode) {940 stack.currentFrame->data = stack.currentFrame->ecode + 1; /* Save for matching */ 941 stack.currentFrame->ecode += 33; /* Advance past the item */ 942 943 switch (*stack.currentFrame->ecode) { 924 944 case OP_CRSTAR: 925 945 case OP_CRMINSTAR: … … 928 948 case OP_CRQUERY: 929 949 case OP_CRMINQUERY: 930 c = * frame->ecode++ - OP_CRSTAR;950 c = *stack.currentFrame->ecode++ - OP_CRSTAR; 931 951 minimize = (c & 1) != 0; 932 952 min = rep_min[c]; /* Pick up values from tables; */ 933 frame->max = rep_max[c]; /* zero for max => infinity */934 if ( frame->max == 0)935 frame->max = INT_MAX;953 stack.currentFrame->max = rep_max[c]; /* zero for max => infinity */ 954 if (stack.currentFrame->max == 0) 955 stack.currentFrame->max = INT_MAX; 936 956 break; 937 957 938 958 case OP_CRRANGE: 939 959 case OP_CRMINRANGE: 940 minimize = (* frame->ecode == OP_CRMINRANGE);941 min = GET2( frame->ecode, 1);942 frame->max = GET2(frame->ecode, 3);943 if ( frame->max == 0)944 frame->max = INT_MAX;945 frame->ecode += 5;960 minimize = (*stack.currentFrame->ecode == OP_CRMINRANGE); 961 min = GET2(stack.currentFrame->ecode, 1); 962 stack.currentFrame->max = GET2(stack.currentFrame->ecode, 3); 963 if (stack.currentFrame->max == 0) 964 stack.currentFrame->max = INT_MAX; 965 stack.currentFrame->ecode += 5; 946 966 break; 947 967 948 968 default: /* No repeat follows */ 949 min = frame->max = 1;969 min = stack.currentFrame->max = 1; 950 970 break; 951 971 } … … 954 974 955 975 for (i = 1; i <= min; i++) { 956 if ( frame->eptr >= md->end_subject)976 if (stack.currentFrame->eptr >= md->end_subject) 957 977 RRETURN_NO_MATCH; 958 GETCHARINC(c, frame->eptr);978 GETCHARINC(c, stack.currentFrame->eptr); 959 979 if (c > 255) { 960 if ( frame->data[-1] == OP_CLASS)980 if (stack.currentFrame->data[-1] == OP_CLASS) 961 981 RRETURN_NO_MATCH; 962 982 } else { 963 if (( frame->data[c/8] & (1 << (c&7))) == 0)983 if ((stack.currentFrame->data[c/8] & (1 << (c&7))) == 0) 964 984 RRETURN_NO_MATCH; 965 985 } … … 969 989 need to recurse. */ 970 990 971 if (min == frame->max)991 if (min == stack.currentFrame->max) 972 992 NEXT_OPCODE; 973 993 … … 976 996 if (minimize) { 977 997 { 978 for ( frame->fi = min;; frame->fi++) {979 RMATCH(22, frame->ecode, frame->eptrb, 0);998 for (stack.currentFrame->fi = min;; stack.currentFrame->fi++) { 999 RMATCH(22, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 980 1000 if (is_match) 981 1001 RRETURN; 982 if ( frame->fi >= frame->max || frame->eptr >= md->end_subject)1002 if (stack.currentFrame->fi >= stack.currentFrame->max || stack.currentFrame->eptr >= md->end_subject) 983 1003 RRETURN; 984 GETCHARINC(c, frame->eptr);1004 GETCHARINC(c, stack.currentFrame->eptr); 985 1005 if (c > 255) { 986 if ( frame->data[-1] == OP_CLASS)1006 if (stack.currentFrame->data[-1] == OP_CLASS) 987 1007 RRETURN; 988 1008 } else { 989 if (( frame->data[c/8] & (1 << (c&7))) == 0)1009 if ((stack.currentFrame->data[c/8] & (1 << (c&7))) == 0) 990 1010 RRETURN; 991 1011 } … … 996 1016 /* If maximizing, find the longest possible run, then work backwards. */ 997 1017 else { 998 frame->pp = frame->eptr;999 1000 for (i = min; i < frame->max; i++) {1018 stack.currentFrame->pp = stack.currentFrame->eptr; 1019 1020 for (i = min; i < stack.currentFrame->max; i++) { 1001 1021 int len = 1; 1002 if ( frame->eptr >= md->end_subject)1003 break; 1004 GETCHARLEN(c, frame->eptr, len);1022 if (stack.currentFrame->eptr >= md->end_subject) 1023 break; 1024 GETCHARLEN(c, stack.currentFrame->eptr, len); 1005 1025 if (c > 255) { 1006 if ( frame->data[-1] == OP_CLASS)1026 if (stack.currentFrame->data[-1] == OP_CLASS) 1007 1027 break; 1008 1028 } else { 1009 if (( frame->data[c/8] & (1 << (c&7))) == 0)1029 if ((stack.currentFrame->data[c/8] & (1 << (c&7))) == 0) 1010 1030 break; 1011 1031 } 1012 frame->eptr += len;1032 stack.currentFrame->eptr += len; 1013 1033 } 1014 1034 for (;;) { 1015 RMATCH(24, frame->ecode, frame->eptrb, 0);1035 RMATCH(24, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1016 1036 if (is_match) 1017 1037 RRETURN; 1018 if ( frame->eptr-- == frame->pp)1038 if (stack.currentFrame->eptr-- == stack.currentFrame->pp) 1019 1039 break; /* Stop if tried at original pos */ 1020 BACKCHAR( frame->eptr);1040 BACKCHAR(stack.currentFrame->eptr); 1021 1041 } 1022 1042 … … 1029 1049 1030 1050 BEGIN_OPCODE(XCLASS): 1031 frame->data = frame->ecode + 1 + LINK_SIZE; /* Save for matching */1032 frame->ecode += GET(frame->ecode, 1); /* Advance past the item */1033 1034 switch (* frame->ecode) {1051 stack.currentFrame->data = stack.currentFrame->ecode + 1 + LINK_SIZE; /* Save for matching */ 1052 stack.currentFrame->ecode += GET(stack.currentFrame->ecode, 1); /* Advance past the item */ 1053 1054 switch (*stack.currentFrame->ecode) { 1035 1055 case OP_CRSTAR: 1036 1056 case OP_CRMINSTAR: … … 1039 1059 case OP_CRQUERY: 1040 1060 case OP_CRMINQUERY: 1041 c = * frame->ecode++ - OP_CRSTAR;1061 c = *stack.currentFrame->ecode++ - OP_CRSTAR; 1042 1062 minimize = (c & 1) != 0; 1043 1063 min = rep_min[c]; /* Pick up values from tables; */ 1044 frame->max = rep_max[c]; /* zero for max => infinity */1045 if ( frame->max == 0)1046 frame->max = INT_MAX;1064 stack.currentFrame->max = rep_max[c]; /* zero for max => infinity */ 1065 if (stack.currentFrame->max == 0) 1066 stack.currentFrame->max = INT_MAX; 1047 1067 break; 1048 1068 1049 1069 case OP_CRRANGE: 1050 1070 case OP_CRMINRANGE: 1051 minimize = (* frame->ecode == OP_CRMINRANGE);1052 min = GET2( frame->ecode, 1);1053 frame->max = GET2(frame->ecode, 3);1054 if ( frame->max == 0)1055 frame->max = INT_MAX;1056 frame->ecode += 5;1071 minimize = (*stack.currentFrame->ecode == OP_CRMINRANGE); 1072 min = GET2(stack.currentFrame->ecode, 1); 1073 stack.currentFrame->max = GET2(stack.currentFrame->ecode, 3); 1074 if (stack.currentFrame->max == 0) 1075 stack.currentFrame->max = INT_MAX; 1076 stack.currentFrame->ecode += 5; 1057 1077 break; 1058 1078 1059 1079 default: /* No repeat follows */ 1060 min = frame->max = 1;1080 min = stack.currentFrame->max = 1; 1061 1081 } 1062 1082 … … 1064 1084 1065 1085 for (i = 1; i <= min; i++) { 1066 if ( frame->eptr >= md->end_subject)1086 if (stack.currentFrame->eptr >= md->end_subject) 1067 1087 RRETURN_NO_MATCH; 1068 GETCHARINC(c, frame->eptr);1069 if (!_pcre_xclass(c, frame->data))1088 GETCHARINC(c, stack.currentFrame->eptr); 1089 if (!_pcre_xclass(c, stack.currentFrame->data)) 1070 1090 RRETURN_NO_MATCH; 1071 1091 } … … 1074 1094 need to recurse. */ 1075 1095 1076 if (min == frame->max)1096 if (min == stack.currentFrame->max) 1077 1097 NEXT_OPCODE; 1078 1098 … … 1081 1101 1082 1102 if (minimize) { 1083 for ( frame->fi = min;; frame->fi++) {1084 RMATCH(26, frame->ecode, frame->eptrb, 0);1103 for (stack.currentFrame->fi = min;; stack.currentFrame->fi++) { 1104 RMATCH(26, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1085 1105 if (is_match) 1086 1106 RRETURN; 1087 if ( frame->fi >= frame->max || frame->eptr >= md->end_subject)1107 if (stack.currentFrame->fi >= stack.currentFrame->max || stack.currentFrame->eptr >= md->end_subject) 1088 1108 RRETURN; 1089 GETCHARINC(c, frame->eptr);1090 if (!_pcre_xclass(c, frame->data))1109 GETCHARINC(c, stack.currentFrame->eptr); 1110 if (!_pcre_xclass(c, stack.currentFrame->data)) 1091 1111 RRETURN; 1092 1112 } … … 1097 1117 1098 1118 else { 1099 frame->pp = frame->eptr;1100 for (i = min; i < frame->max; i++) {1119 stack.currentFrame->pp = stack.currentFrame->eptr; 1120 for (i = min; i < stack.currentFrame->max; i++) { 1101 1121 int len = 1; 1102 if ( frame->eptr >= md->end_subject)1103 break; 1104 GETCHARLEN(c, frame->eptr, len);1105 if (!_pcre_xclass(c, frame->data))1106 break; 1107 frame->eptr += len;1122 if (stack.currentFrame->eptr >= md->end_subject) 1123 break; 1124 GETCHARLEN(c, stack.currentFrame->eptr, len); 1125 if (!_pcre_xclass(c, stack.currentFrame->data)) 1126 break; 1127 stack.currentFrame->eptr += len; 1108 1128 } 1109 1129 for(;;) { 1110 RMATCH(27, frame->ecode, frame->eptrb, 0);1130 RMATCH(27, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1111 1131 if (is_match) 1112 1132 RRETURN; 1113 if ( frame->eptr-- == frame->pp)1133 if (stack.currentFrame->eptr-- == stack.currentFrame->pp) 1114 1134 break; /* Stop if tried at original pos */ 1115 BACKCHAR( frame->eptr)1135 BACKCHAR(stack.currentFrame->eptr) 1116 1136 } 1117 1137 RRETURN; … … 1123 1143 1124 1144 BEGIN_OPCODE(CHAR): 1125 frame->length = 1;1126 frame->ecode++;1127 GETUTF8CHARLEN( frame->fc, frame->ecode, frame->length);1145 stack.currentFrame->length = 1; 1146 stack.currentFrame->ecode++; 1147 GETUTF8CHARLEN(stack.currentFrame->fc, stack.currentFrame->ecode, stack.currentFrame->length); 1128 1148 { 1129 1149 int dc; 1130 frame->ecode += frame->length;1131 switch (md->end_subject - frame->eptr) {1150 stack.currentFrame->ecode += stack.currentFrame->length; 1151 switch (md->end_subject - stack.currentFrame->eptr) { 1132 1152 case 0: 1133 1153 RRETURN_NO_MATCH; 1134 1154 case 1: 1135 dc = * frame->eptr++;1155 dc = *stack.currentFrame->eptr++; 1136 1156 if (IS_LEADING_SURROGATE(dc)) 1137 1157 RRETURN_NO_MATCH; 1138 1158 break; 1139 1159 default: 1140 GETCHARINC(dc, frame->eptr);1141 } 1142 if ( frame->fc != dc)1160 GETCHARINC(dc, stack.currentFrame->eptr); 1161 } 1162 if (stack.currentFrame->fc != dc) 1143 1163 RRETURN_NO_MATCH; 1144 1164 } … … 1148 1168 1149 1169 BEGIN_OPCODE(CHARNC): 1150 frame->length = 1;1151 frame->ecode++;1152 GETUTF8CHARLEN( frame->fc, frame->ecode, frame->length);1153 1154 if (md->end_subject - frame->eptr == 0)1170 stack.currentFrame->length = 1; 1171 stack.currentFrame->ecode++; 1172 GETUTF8CHARLEN(stack.currentFrame->fc, stack.currentFrame->ecode, stack.currentFrame->length); 1173 1174 if (md->end_subject - stack.currentFrame->eptr == 0) 1155 1175 RRETURN_NO_MATCH; 1156 1176 1157 1177 { 1158 1178 int dc; 1159 if (md->end_subject - frame->eptr == 1) {1160 dc = * frame->eptr++;1179 if (md->end_subject - stack.currentFrame->eptr == 1) { 1180 dc = *stack.currentFrame->eptr++; 1161 1181 if (IS_LEADING_SURROGATE(dc)) 1162 1182 RRETURN_NO_MATCH; 1163 1183 } else 1164 GETCHARINC(dc, frame->eptr);1165 frame->ecode += frame->length;1184 GETCHARINC(dc, stack.currentFrame->eptr); 1185 stack.currentFrame->ecode += stack.currentFrame->length; 1166 1186 1167 1187 /* If we have Unicode property support, we can use it to test the other 1168 1188 case of the character, if there is one. */ 1169 1189 1170 if ( frame->fc != dc) {1171 if (dc != _pcre_ucp_othercase( frame->fc))1190 if (stack.currentFrame->fc != dc) { 1191 if (dc != _pcre_ucp_othercase(stack.currentFrame->fc)) 1172 1192 RRETURN_NO_MATCH; 1173 1193 } … … 1178 1198 1179 1199 BEGIN_OPCODE(ASCII_CHAR): 1180 if (md->end_subject == frame->eptr)1181 RRETURN_NO_MATCH; 1182 if (* frame->eptr != frame->ecode[1])1183 RRETURN_NO_MATCH; 1184 ++ frame->eptr;1185 frame->ecode += 2;1200 if (md->end_subject == stack.currentFrame->eptr) 1201 RRETURN_NO_MATCH; 1202 if (*stack.currentFrame->eptr != stack.currentFrame->ecode[1]) 1203 RRETURN_NO_MATCH; 1204 ++stack.currentFrame->eptr; 1205 stack.currentFrame->ecode += 2; 1186 1206 NEXT_OPCODE; 1187 1207 … … 1189 1209 1190 1210 BEGIN_OPCODE(ASCII_LETTER_NC): 1191 if (md->end_subject == frame->eptr)1192 RRETURN_NO_MATCH; 1193 if ((* frame->eptr | 0x20) != frame->ecode[1])1194 RRETURN_NO_MATCH; 1195 ++ frame->eptr;1196 frame->ecode += 2;1211 if (md->end_subject == stack.currentFrame->eptr) 1212 RRETURN_NO_MATCH; 1213 if ((*stack.currentFrame->eptr | 0x20) != stack.currentFrame->ecode[1]) 1214 RRETURN_NO_MATCH; 1215 ++stack.currentFrame->eptr; 1216 stack.currentFrame->ecode += 2; 1197 1217 NEXT_OPCODE; 1198 1218 … … 1200 1220 1201 1221 BEGIN_OPCODE(EXACT): 1202 min = frame->max = GET2(frame->ecode, 1);1222 min = stack.currentFrame->max = GET2(stack.currentFrame->ecode, 1); 1203 1223 minimize = false; 1204 frame->ecode += 3;1224 stack.currentFrame->ecode += 3; 1205 1225 goto REPEATCHAR; 1206 1226 … … 1208 1228 BEGIN_OPCODE(MINUPTO): 1209 1229 min = 0; 1210 frame->max = GET2(frame->ecode, 1);1211 minimize = * frame->ecode == OP_MINUPTO;1212 frame->ecode += 3;1230 stack.currentFrame->max = GET2(stack.currentFrame->ecode, 1); 1231 minimize = *stack.currentFrame->ecode == OP_MINUPTO; 1232 stack.currentFrame->ecode += 3; 1213 1233 goto REPEATCHAR; 1214 1234 … … 1219 1239 BEGIN_OPCODE(QUERY): 1220 1240 BEGIN_OPCODE(MINQUERY): 1221 c = * frame->ecode++ - OP_STAR;1241 c = *stack.currentFrame->ecode++ - OP_STAR; 1222 1242 minimize = (c & 1) != 0; 1223 1243 min = rep_min[c]; /* Pick up values from tables; */ 1224 frame->max = rep_max[c]; /* zero for max => infinity */1225 if ( frame->max == 0)1226 frame->max = INT_MAX;1244 stack.currentFrame->max = rep_max[c]; /* zero for max => infinity */ 1245 if (stack.currentFrame->max == 0) 1246 stack.currentFrame->max = INT_MAX; 1227 1247 1228 1248 /* Common code for all repeated single-character matches. We can give … … 1232 1252 REPEATCHAR: 1233 1253 1234 frame->length = 1;1235 GETUTF8CHARLEN( frame->fc, frame->ecode, frame->length);1236 if (min * ( frame->fc > 0xFFFF ? 2 : 1) > md->end_subject - frame->eptr)1237 RRETURN_NO_MATCH; 1238 frame->ecode += frame->length;1239 1240 if ( frame->fc <= 0xFFFF) {1241 int othercase = md->caseless ? _pcre_ucp_othercase( frame->fc) : -1;1254 stack.currentFrame->length = 1; 1255 GETUTF8CHARLEN(stack.currentFrame->fc, stack.currentFrame->ecode, stack.currentFrame->length); 1256 if (min * (stack.currentFrame->fc > 0xFFFF ? 2 : 1) > md->end_subject - stack.currentFrame->eptr) 1257 RRETURN_NO_MATCH; 1258 stack.currentFrame->ecode += stack.currentFrame->length; 1259 1260 if (stack.currentFrame->fc <= 0xFFFF) { 1261 int othercase = md->caseless ? _pcre_ucp_othercase(stack.currentFrame->fc) : -1; 1242 1262 1243 1263 for (i = 1; i <= min; i++) { 1244 if (* frame->eptr != frame->fc && *frame->eptr != othercase)1264 if (*stack.currentFrame->eptr != stack.currentFrame->fc && *stack.currentFrame->eptr != othercase) 1245 1265 RRETURN_NO_MATCH; 1246 ++ frame->eptr;1266 ++stack.currentFrame->eptr; 1247 1267 } 1248 1268 1249 if (min == frame->max)1269 if (min == stack.currentFrame->max) 1250 1270 NEXT_OPCODE; 1251 1271 1252 1272 if (minimize) { 1253 frame->repeat_othercase = othercase;1254 for ( frame->fi = min;; frame->fi++) {1255 RMATCH(28, frame->ecode, frame->eptrb, 0);1273 stack.currentFrame->repeat_othercase = othercase; 1274 for (stack.currentFrame->fi = min;; stack.currentFrame->fi++) { 1275 RMATCH(28, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1256 1276 if (is_match) 1257 1277 RRETURN; 1258 if ( frame->fi >= frame->max || frame->eptr >= md->end_subject)1278 if (stack.currentFrame->fi >= stack.currentFrame->max || stack.currentFrame->eptr >= md->end_subject) 1259 1279 RRETURN; 1260 if (* frame->eptr != frame->fc && *frame->eptr != frame->repeat_othercase)1280 if (*stack.currentFrame->eptr != stack.currentFrame->fc && *stack.currentFrame->eptr != stack.currentFrame->repeat_othercase) 1261 1281 RRETURN; 1262 ++ frame->eptr;1282 ++stack.currentFrame->eptr; 1263 1283 } 1264 1284 ASSERT_NOT_REACHED(); 1265 1285 } else { 1266 frame->pp = frame->eptr;1267 for (i = min; i < frame->max; i++) {1268 if ( frame->eptr >= md->end_subject)1286 stack.currentFrame->pp = stack.currentFrame->eptr; 1287 for (i = min; i < stack.currentFrame->max; i++) { 1288 if (stack.currentFrame->eptr >= md->end_subject) 1269 1289 break; 1270 if (* frame->eptr != frame->fc && *frame->eptr != othercase)1290 if (*stack.currentFrame->eptr != stack.currentFrame->fc && *stack.currentFrame->eptr != othercase) 1271 1291 break; 1272 ++ frame->eptr;1292 ++stack.currentFrame->eptr; 1273 1293 } 1274 while ( frame->eptr >= frame->pp) {1275 RMATCH(29, frame->ecode, frame->eptrb, 0);1294 while (stack.currentFrame->eptr >= stack.currentFrame->pp) { 1295 RMATCH(29, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1276 1296 if (is_match) 1277 1297 RRETURN; 1278 -- frame->eptr;1298 --stack.currentFrame->eptr; 1279 1299 } 1280 1300 RRETURN_NO_MATCH; … … 1286 1306 for (i = 1; i <= min; i++) { 1287 1307 int nc; 1288 GETCHAR(nc, frame->eptr);1289 if (nc != frame->fc)1308 GETCHAR(nc, stack.currentFrame->eptr); 1309 if (nc != stack.currentFrame->fc) 1290 1310 RRETURN_NO_MATCH; 1291 frame->eptr += 2;1311 stack.currentFrame->eptr += 2; 1292 1312 } 1293 1313 1294 if (min == frame->max)1314 if (min == stack.currentFrame->max) 1295 1315 NEXT_OPCODE; 1296 1316 1297 1317 if (minimize) { 1298 for ( frame->fi = min;; frame->fi++) {1318 for (stack.currentFrame->fi = min;; stack.currentFrame->fi++) { 1299 1319 int nc; 1300 RMATCH(30, frame->ecode, frame->eptrb, 0);1320 RMATCH(30, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1301 1321 if (is_match) 1302 1322 RRETURN; 1303 if ( frame->fi >= frame->max || frame->eptr >= md->end_subject)1323 if (stack.currentFrame->fi >= stack.currentFrame->max || stack.currentFrame->eptr >= md->end_subject) 1304 1324 RRETURN; 1305 GETCHAR(nc, frame->eptr);1306 if (* frame->eptr != frame->fc)1325 GETCHAR(nc, stack.currentFrame->eptr); 1326 if (*stack.currentFrame->eptr != stack.currentFrame->fc) 1307 1327 RRETURN; 1308 frame->eptr += 2;1328 stack.currentFrame->eptr += 2; 1309 1329 } 1310 1330 ASSERT_NOT_REACHED(); 1311 1331 } else { 1312 frame->pp = frame->eptr;1313 for (i = min; i < frame->max; i++) {1332 stack.currentFrame->pp = stack.currentFrame->eptr; 1333 for (i = min; i < stack.currentFrame->max; i++) { 1314 1334 int nc; 1315 if ( frame->eptr > md->end_subject - 2)1335 if (stack.currentFrame->eptr > md->end_subject - 2) 1316 1336 break; 1317 GETCHAR(nc, frame->eptr);1318 if (* frame->eptr != frame->fc)1337 GETCHAR(nc, stack.currentFrame->eptr); 1338 if (*stack.currentFrame->eptr != stack.currentFrame->fc) 1319 1339 break; 1320 frame->eptr += 2;1340 stack.currentFrame->eptr += 2; 1321 1341 } 1322 while ( frame->eptr >= frame->pp) {1323 RMATCH(31, frame->ecode, frame->eptrb, 0);1342 while (stack.currentFrame->eptr >= stack.currentFrame->pp) { 1343 RMATCH(31, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1324 1344 if (is_match) 1325 1345 RRETURN; 1326 frame->eptr -= 2;1346 stack.currentFrame->eptr -= 2; 1327 1347 } 1328 1348 RRETURN_NO_MATCH; … … 1336 1356 1337 1357 BEGIN_OPCODE(NOT): 1338 if ( frame->eptr >= md->end_subject)1339 RRETURN_NO_MATCH; 1340 frame->ecode++;1341 GETCHARINCTEST(c, frame->eptr);1358 if (stack.currentFrame->eptr >= md->end_subject) 1359 RRETURN_NO_MATCH; 1360 stack.currentFrame->ecode++; 1361 GETCHARINCTEST(c, stack.currentFrame->eptr); 1342 1362 if (md->caseless) { 1343 1363 if (c < 128) 1344 1364 c = md->lcc[c]; 1345 if (md->lcc[* frame->ecode++] == c)1365 if (md->lcc[*stack.currentFrame->ecode++] == c) 1346 1366 RRETURN_NO_MATCH; 1347 1367 } else { 1348 if (* frame->ecode++ == c)1368 if (*stack.currentFrame->ecode++ == c) 1349 1369 RRETURN_NO_MATCH; 1350 1370 } … … 1359 1379 1360 1380 BEGIN_OPCODE(NOTEXACT): 1361 min = frame->max = GET2(frame->ecode, 1);1381 min = stack.currentFrame->max = GET2(stack.currentFrame->ecode, 1); 1362 1382 minimize = false; 1363 frame->ecode += 3;1383 stack.currentFrame->ecode += 3; 1364 1384 goto REPEATNOTCHAR; 1365 1385 … … 1367 1387 BEGIN_OPCODE(NOTMINUPTO): 1368 1388 min = 0; 1369 frame->max = GET2(frame->ecode, 1);1370 minimize = * frame->ecode == OP_NOTMINUPTO;1371 frame->ecode += 3;1389 stack.currentFrame->max = GET2(stack.currentFrame->ecode, 1); 1390 minimize = *stack.currentFrame->ecode == OP_NOTMINUPTO; 1391 stack.currentFrame->ecode += 3; 1372 1392 goto REPEATNOTCHAR; 1373 1393 … … 1378 1398 BEGIN_OPCODE(NOTQUERY): 1379 1399 BEGIN_OPCODE(NOTMINQUERY): 1380 c = * frame->ecode++ - OP_NOTSTAR;1400 c = *stack.currentFrame->ecode++ - OP_NOTSTAR; 1381 1401 minimize = (c & 1) != 0; 1382 1402 min = rep_min[c]; /* Pick up values from tables; */ 1383 frame->max = rep_max[c]; /* zero for max => infinity */1384 if ( frame->max == 0) frame->max = INT_MAX;1403 stack.currentFrame->max = rep_max[c]; /* zero for max => infinity */ 1404 if (stack.currentFrame->max == 0) stack.currentFrame->max = INT_MAX; 1385 1405 1386 1406 /* Common code for all repeated single-byte matches. We can give up quickly … … 1389 1409 1390 1410 REPEATNOTCHAR: 1391 if (min > md->end_subject - frame->eptr)1392 RRETURN_NO_MATCH; 1393 frame->fc = *frame->ecode++;1411 if (min > md->end_subject - stack.currentFrame->eptr) 1412 RRETURN_NO_MATCH; 1413 stack.currentFrame->fc = *stack.currentFrame->ecode++; 1394 1414 1395 1415 /* The code is duplicated for the caseless and caseful cases, for speed, … … 1401 1421 characters and work backwards. */ 1402 1422 1403 DPRINTF(("negative matching %c{%d,%d}\n", frame->fc, min, frame->max));1423 DPRINTF(("negative matching %c{%d,%d}\n", stack.currentFrame->fc, min, stack.currentFrame->max)); 1404 1424 1405 1425 if (md->caseless) { 1406 if ( frame->fc < 128)1407 frame->fc = md->lcc[frame->fc];1426 if (stack.currentFrame->fc < 128) 1427 stack.currentFrame->fc = md->lcc[stack.currentFrame->fc]; 1408 1428 1409 1429 { 1410 1430 register int d; 1411 1431 for (i = 1; i <= min; i++) { 1412 GETCHARINC(d, frame->eptr);1432 GETCHARINC(d, stack.currentFrame->eptr); 1413 1433 if (d < 128) 1414 1434 d = md->lcc[d]; 1415 if ( frame->fc == d)1435 if (stack.currentFrame->fc == d) 1416 1436 RRETURN_NO_MATCH; 1417 1437 } 1418 1438 } 1419 1439 1420 if (min == frame->max)1440 if (min == stack.currentFrame->max) 1421 1441 NEXT_OPCODE; 1422 1442 1423 1443 if (minimize) { 1424 1444 register int d; 1425 for ( frame->fi = min;; frame->fi++) {1426 RMATCH(38, frame->ecode, frame->eptrb, 0);1445 for (stack.currentFrame->fi = min;; stack.currentFrame->fi++) { 1446 RMATCH(38, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1427 1447 if (is_match) 1428 1448 RRETURN; 1429 GETCHARINC(d, frame->eptr);1449 GETCHARINC(d, stack.currentFrame->eptr); 1430 1450 if (d < 128) 1431 1451 d = md->lcc[d]; 1432 if ( frame->fi >= frame->max || frame->eptr >= md->end_subject || frame->fc == d)1452 if (stack.currentFrame->fi >= stack.currentFrame->max || stack.currentFrame->eptr >= md->end_subject || stack.currentFrame->fc == d) 1433 1453 RRETURN; 1434 1454 } … … 1439 1459 1440 1460 else { 1441 frame->pp = frame->eptr;1461 stack.currentFrame->pp = stack.currentFrame->eptr; 1442 1462 1443 1463 { 1444 1464 register int d; 1445 for (i = min; i < frame->max; i++) {1465 for (i = min; i < stack.currentFrame->max; i++) { 1446 1466 int len = 1; 1447 if ( frame->eptr >= md->end_subject)1467 if (stack.currentFrame->eptr >= md->end_subject) 1448 1468 break; 1449 GETCHARLEN(d, frame->eptr, len);1469 GETCHARLEN(d, stack.currentFrame->eptr, len); 1450 1470 if (d < 128) 1451 1471 d = md->lcc[d]; 1452 if ( frame->fc == d)1472 if (stack.currentFrame->fc == d) 1453 1473 break; 1454 frame->eptr += len;1474 stack.currentFrame->eptr += len; 1455 1475 } 1456 1476 for (;;) { 1457 RMATCH(40, frame->ecode, frame->eptrb, 0);1477 RMATCH(40, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1458 1478 if (is_match) 1459 1479 RRETURN; 1460 if ( frame->eptr-- == frame->pp)1480 if (stack.currentFrame->eptr-- == stack.currentFrame->pp) 1461 1481 break; /* Stop if tried at original pos */ 1462 BACKCHAR( frame->eptr);1482 BACKCHAR(stack.currentFrame->eptr); 1463 1483 } 1464 1484 } … … 1475 1495 register int d; 1476 1496 for (i = 1; i <= min; i++) { 1477 GETCHARINC(d, frame->eptr);1478 if ( frame->fc == d)1497 GETCHARINC(d, stack.currentFrame->eptr); 1498 if (stack.currentFrame->fc == d) 1479 1499 RRETURN_NO_MATCH; 1480 1500 } 1481 1501 } 1482 1502 1483 if (min == frame->max)1503 if (min == stack.currentFrame->max) 1484 1504 NEXT_OPCODE; 1485 1505 1486 1506 if (minimize) { 1487 1507 register int d; 1488 for ( frame->fi = min;; frame->fi++) {1489 RMATCH(42, frame->ecode, frame->eptrb, 0);1508 for (stack.currentFrame->fi = min;; stack.currentFrame->fi++) { 1509 RMATCH(42, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1490 1510 if (is_match) 1491 1511 RRETURN; 1492 GETCHARINC(d, frame->eptr);1493 if ( frame->fi >= frame->max || frame->eptr >= md->end_subject || frame->fc == d)1512 GETCHARINC(d, stack.currentFrame->eptr); 1513 if (stack.currentFrame->fi >= stack.currentFrame->max || stack.currentFrame->eptr >= md->end_subject || stack.currentFrame->fc == d) 1494 1514 RRETURN; 1495 1515 } … … 1500 1520 1501 1521 else { 1502 frame->pp = frame->eptr;1522 stack.currentFrame->pp = stack.currentFrame->eptr; 1503 1523 1504 1524 { 1505 1525 register int d; 1506 for (i = min; i < frame->max; i++) {1526 for (i = min; i < stack.currentFrame->max; i++) { 1507 1527 int len = 1; 1508 if ( frame->eptr >= md->end_subject)1528 if (stack.currentFrame->eptr >= md->end_subject) 1509 1529 break; 1510 GETCHARLEN(d, frame->eptr, len);1511 if ( frame->fc == d)1530 GETCHARLEN(d, stack.currentFrame->eptr, len); 1531 if (stack.currentFrame->fc == d) 1512 1532 break; 1513 frame->eptr += len;1533 stack.currentFrame->eptr += len; 1514 1534 } 1515 1535 for (;;) { 1516 RMATCH(44, frame->ecode, frame->eptrb, 0);1536 RMATCH(44, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1517 1537 if (is_match) 1518 1538 RRETURN; 1519 if ( frame->eptr-- == frame->pp)1539 if (stack.currentFrame->eptr-- == stack.currentFrame->pp) 1520 1540 break; /* Stop if tried at original pos */ 1521 BACKCHAR( frame->eptr);1541 BACKCHAR(stack.currentFrame->eptr); 1522 1542 } 1523 1543 } … … 1533 1553 1534 1554 BEGIN_OPCODE(TYPEEXACT): 1535 min = frame->max = GET2(frame->ecode, 1);1555 min = stack.currentFrame->max = GET2(stack.currentFrame->ecode, 1); 1536 1556 minimize = true; 1537 frame->ecode += 3;1557 stack.currentFrame->ecode += 3; 1538 1558 goto REPEATTYPE; 1539 1559 … … 1541 1561 BEGIN_OPCODE(TYPEMINUPTO): 1542 1562 min = 0; 1543 frame->max = GET2(frame->ecode, 1);1544 minimize = * frame->ecode == OP_TYPEMINUPTO;1545 frame->ecode += 3;1563 stack.currentFrame->max = GET2(stack.currentFrame->ecode, 1); 1564 minimize = *stack.currentFrame->ecode == OP_TYPEMINUPTO; 1565 stack.currentFrame->ecode += 3; 1546 1566 goto REPEATTYPE; 1547 1567 … … 1552 1572 BEGIN_OPCODE(TYPEQUERY): 1553 1573 BEGIN_OPCODE(TYPEMINQUERY): 1554 c = * frame->ecode++ - OP_TYPESTAR;1574 c = *stack.currentFrame->ecode++ - OP_TYPESTAR; 1555 1575 minimize = (c & 1) != 0; 1556 1576 min = rep_min[c]; /* Pick up values from tables; */ 1557 frame->max = rep_max[c]; /* zero for max => infinity */1558 if ( frame->max == 0)1559 frame->max = INT_MAX;1577 stack.currentFrame->max = rep_max[c]; /* zero for max => infinity */ 1578 if (stack.currentFrame->max == 0) 1579 stack.currentFrame->max = INT_MAX; 1560 1580 1561 1581 /* Common code for all repeated single character type matches. Note that … … 1564 1584 1565 1585 REPEATTYPE: 1566 frame->ctype = *frame->ecode++; /* Code for the character type */1586 stack.currentFrame->ctype = *stack.currentFrame->ecode++; /* Code for the character type */ 1567 1587 1568 1588 /* First, ensure the minimum number of matches are present. Use inline … … 1574 1594 and single-bytes. */ 1575 1595 1576 if (min > md->end_subject - frame->eptr)1596 if (min > md->end_subject - stack.currentFrame->eptr) 1577 1597 RRETURN_NO_MATCH; 1578 1598 if (min > 0) { 1579 switch( frame->ctype) {1599 switch(stack.currentFrame->ctype) { 1580 1600 case OP_ANY: 1581 1601 for (i = 1; i <= min; i++) { 1582 if ( frame->eptr >= md->end_subject || isNewline(*frame->eptr))1602 if (stack.currentFrame->eptr >= md->end_subject || isNewline(*stack.currentFrame->eptr)) 1583 1603 RRETURN_NO_MATCH; 1584 ++ frame->eptr;1585 while ( frame->eptr < md->end_subject && ISMIDCHAR(*frame->eptr))1586 frame->eptr++;1604 ++stack.currentFrame->eptr; 1605 while (stack.currentFrame->eptr < md->end_subject && ISMIDCHAR(*stack.currentFrame->eptr)) 1606 stack.currentFrame->eptr++; 1587 1607 } 1588 1608 break; … … 1590 1610 case OP_NOT_DIGIT: 1591 1611 for (i = 1; i <= min; i++) { 1592 if ( frame->eptr >= md->end_subject)1612 if (stack.currentFrame->eptr >= md->end_subject) 1593 1613 RRETURN_NO_MATCH; 1594 GETCHARINC(c, frame->eptr);1614 GETCHARINC(c, stack.currentFrame->eptr); 1595 1615 if (isASCIIDigit(c)) 1596 1616 RRETURN_NO_MATCH; … … 1600 1620 case OP_DIGIT: 1601 1621 for (i = 1; i <= min; i++) { 1602 if ( frame->eptr >= md->end_subject || !isASCIIDigit(*frame->eptr++))1622 if (stack.currentFrame->eptr >= md->end_subject || !isASCIIDigit(*stack.currentFrame->eptr++)) 1603 1623 RRETURN_NO_MATCH; 1604 1624 /* No need to skip more bytes - we know it's a 1-byte character */ … … 1608 1628 case OP_NOT_WHITESPACE: 1609 1629 for (i = 1; i <= min; i++) { 1610 if ( frame->eptr >= md->end_subject ||1611 (* frame->eptr < 128 && (md->ctypes[*frame->eptr] & ctype_space) != 0))1630 if (stack.currentFrame->eptr >= md->end_subject || 1631 (*stack.currentFrame->eptr < 128 && (md->ctypes[*stack.currentFrame->eptr] & ctype_space) != 0)) 1612 1632 RRETURN_NO_MATCH; 1613 while (++ frame->eptr < md->end_subject && ISMIDCHAR(*frame->eptr));1633 while (++stack.currentFrame->eptr < md->end_subject && ISMIDCHAR(*stack.currentFrame->eptr)); 1614 1634 } 1615 1635 break; … … 1617 1637 case OP_WHITESPACE: 1618 1638 for (i = 1; i <= min; i++) { 1619 if ( frame->eptr >= md->end_subject ||1620 * frame->eptr >= 128 || (md->ctypes[*frame->eptr++] & ctype_space) == 0)1639 if (stack.currentFrame->eptr >= md->end_subject || 1640 *stack.currentFrame->eptr >= 128 || (md->ctypes[*stack.currentFrame->eptr++] & ctype_space) == 0) 1621 1641 RRETURN_NO_MATCH; 1622 1642 /* No need to skip more bytes - we know it's a 1-byte character */ … … 1626 1646 case OP_NOT_WORDCHAR: 1627 1647 for (i = 1; i <= min; i++) { 1628 if ( frame->eptr >= md->end_subject ||1629 (* frame->eptr < 128 && (md->ctypes[*frame->eptr] & ctype_word) != 0))1648 if (stack.currentFrame->eptr >= md->end_subject || 1649 (*stack.currentFrame->eptr < 128 && (md->ctypes[*stack.currentFrame->eptr] & ctype_word) != 0)) 1630 1650 RRETURN_NO_MATCH; 1631 while (++ frame->eptr < md->end_subject && ISMIDCHAR(*frame->eptr));1651 while (++stack.currentFrame->eptr < md->end_subject && ISMIDCHAR(*stack.currentFrame->eptr)); 1632 1652 } 1633 1653 break; … … 1635 1655 case OP_WORDCHAR: 1636 1656 for (i = 1; i <= min; i++) { 1637 if ( frame->eptr >= md->end_subject ||1638 * frame->eptr >= 128 || (md->ctypes[*frame->eptr++] & ctype_word) == 0)1657 if (stack.currentFrame->eptr >= md->end_subject || 1658 *stack.currentFrame->eptr >= 128 || (md->ctypes[*stack.currentFrame->eptr++] & ctype_word) == 0) 1639 1659 RRETURN_NO_MATCH; 1640 1660 /* No need to skip more bytes - we know it's a 1-byte character */ … … 1645 1665 ASSERT_NOT_REACHED(); 1646 1666 RRETURN_ERROR(JSRegExpErrorInternal); 1647 } /* End switch( frame->ctype) */1667 } /* End switch(stack.currentFrame->ctype) */ 1648 1668 } 1649 1669 1650 1670 /* If min = max, continue at the same level without recursing */ 1651 1671 1652 if (min == frame->max)1672 if (min == stack.currentFrame->max) 1653 1673 NEXT_OPCODE; 1654 1674 … … 1657 1677 1658 1678 if (minimize) { 1659 for ( frame->fi = min;; frame->fi++) {1660 RMATCH(48, frame->ecode, frame->eptrb, 0);1679 for (stack.currentFrame->fi = min;; stack.currentFrame->fi++) { 1680 RMATCH(48, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1661 1681 if (is_match) 1662 1682 RRETURN; 1663 if ( frame->fi >= frame->max || frame->eptr >= md->end_subject)1683 if (stack.currentFrame->fi >= stack.currentFrame->max || stack.currentFrame->eptr >= md->end_subject) 1664 1684 RRETURN; 1665 1685 1666 GETCHARINC(c, frame->eptr);1667 switch( frame->ctype) {1686 GETCHARINC(c, stack.currentFrame->eptr); 1687 switch(stack.currentFrame->ctype) { 1668 1688 case OP_ANY: 1669 1689 if (isNewline(c)) … … 1713 1733 1714 1734 else { 1715 frame->pp = frame->eptr; /* Remember where we started */1716 1717 switch( frame->ctype) {1735 stack.currentFrame->pp = stack.currentFrame->eptr; /* Remember where we started */ 1736 1737 switch(stack.currentFrame->ctype) { 1718 1738 case OP_ANY: 1719 1739 … … 1722 1742 worth it, because .* is quite a common idiom. */ 1723 1743 1724 if ( frame->max < INT_MAX) {1725 for (i = min; i < frame->max; i++) {1726 if ( frame->eptr >= md->end_subject || isNewline(*frame->eptr))1744 if (stack.currentFrame->max < INT_MAX) { 1745 for (i = min; i < stack.currentFrame->max; i++) { 1746 if (stack.currentFrame->eptr >= md->end_subject || isNewline(*stack.currentFrame->eptr)) 1727 1747 break; 1728 frame->eptr++;1729 while ( frame->eptr < md->end_subject && (*frame->eptr & 0xc0) == 0x80)1730 frame->eptr++;1748 stack.currentFrame->eptr++; 1749 while (stack.currentFrame->eptr < md->end_subject && (*stack.currentFrame->eptr & 0xc0) == 0x80) 1750 stack.currentFrame->eptr++; 1731 1751 } 1732 1752 } … … 1735 1755 1736 1756 else { 1737 for (i = min; i < frame->max; i++) {1738 if ( frame->eptr >= md->end_subject || isNewline(*frame->eptr))1757 for (i = min; i < stack.currentFrame->max; i++) { 1758 if (stack.currentFrame->eptr >= md->end_subject || isNewline(*stack.currentFrame->eptr)) 1739 1759 break; 1740 frame->eptr++;1760 stack.currentFrame->eptr++; 1741 1761 } 1742 1762 break; … … 1745 1765 1746 1766 case OP_NOT_DIGIT: 1747 for (i = min; i < frame->max; i++) {1767 for (i = min; i < stack.currentFrame->max; i++) { 1748 1768 int len = 1; 1749 if ( frame->eptr >= md->end_subject)1769 if (stack.currentFrame->eptr >= md->end_subject) 1750 1770 break; 1751 GETCHARLEN(c, frame->eptr, len);1771 GETCHARLEN(c, stack.currentFrame->eptr, len); 1752 1772 if (isASCIIDigit(c)) 1753 1773 break; 1754 frame->eptr+= len;1774 stack.currentFrame->eptr+= len; 1755 1775 } 1756 1776 break; 1757 1777 1758 1778 case OP_DIGIT: 1759 for (i = min; i < frame->max; i++) {1779 for (i = min; i < stack.currentFrame->max; i++) { 1760 1780 int len = 1; 1761 if ( frame->eptr >= md->end_subject)1781 if (stack.currentFrame->eptr >= md->end_subject) 1762 1782 break; 1763 GETCHARLEN(c, frame->eptr, len);1783 GETCHARLEN(c, stack.currentFrame->eptr, len); 1764 1784 if (!isASCIIDigit(c)) 1765 1785 break; 1766 frame->eptr+= len;1786 stack.currentFrame->eptr+= len; 1767 1787 } 1768 1788 break; 1769 1789 1770 1790 case OP_NOT_WHITESPACE: 1771 for (i = min; i < frame->max; i++) {1791 for (i = min; i < stack.currentFrame->max; i++) { 1772 1792 int len = 1; 1773 if ( frame->eptr >= md->end_subject)1793 if (stack.currentFrame->eptr >= md->end_subject) 1774 1794 break; 1775 GETCHARLEN(c, frame->eptr, len);1795 GETCHARLEN(c, stack.currentFrame->eptr, len); 1776 1796 if (c < 128 && (md->ctypes[c] & ctype_space)) 1777 1797 break; 1778 frame->eptr+= len;1798 stack.currentFrame->eptr+= len; 1779 1799 } 1780 1800 break; 1781 1801 1782 1802 case OP_WHITESPACE: 1783 for (i = min; i < frame->max; i++) {1803 for (i = min; i < stack.currentFrame->max; i++) { 1784 1804 int len = 1; 1785 if ( frame->eptr >= md->end_subject)1805 if (stack.currentFrame->eptr >= md->end_subject) 1786 1806 break; 1787 GETCHARLEN(c, frame->eptr, len);1807 GETCHARLEN(c, stack.currentFrame->eptr, len); 1788 1808 if (c >= 128 || !(md->ctypes[c] & ctype_space)) 1789 1809 break; 1790 frame->eptr+= len;1810 stack.currentFrame->eptr+= len; 1791 1811 } 1792 1812 break; 1793 1813 1794 1814 case OP_NOT_WORDCHAR: 1795 for (i = min; i < frame->max; i++) {1815 for (i = min; i < stack.currentFrame->max; i++) { 1796 1816 int len = 1; 1797 if ( frame->eptr >= md->end_subject)1817 if (stack.currentFrame->eptr >= md->end_subject) 1798 1818 break; 1799 GETCHARLEN(c, frame->eptr, len);1819 GETCHARLEN(c, stack.currentFrame->eptr, len); 1800 1820 if (c < 128 && (md->ctypes[c] & ctype_word)) 1801 1821 break; 1802 frame->eptr+= len;1822 stack.currentFrame->eptr+= len; 1803 1823 } 1804 1824 break; 1805 1825 1806 1826 case OP_WORDCHAR: 1807 for (i = min; i < frame->max; i++) {1827 for (i = min; i < stack.currentFrame->max; i++) { 1808 1828 int len = 1; 1809 if ( frame->eptr >= md->end_subject)1829 if (stack.currentFrame->eptr >= md->end_subject) 1810 1830 break; 1811 GETCHARLEN(c, frame->eptr, len);1831 GETCHARLEN(c, stack.currentFrame->eptr, len); 1812 1832 if (c >= 128 || !(md->ctypes[c] & ctype_word)) 1813 1833 break; 1814 frame->eptr+= len;1834 stack.currentFrame->eptr+= len; 1815 1835 } 1816 1836 break; … … 1821 1841 } 1822 1842 1823 /* frame->eptr is now past the end of the maximum run */1843 /* stack.currentFrame->eptr is now past the end of the maximum run */ 1824 1844 1825 1845 for (;;) { 1826 RMATCH(52, frame->ecode, frame->eptrb, 0);1846 RMATCH(52, stack.currentFrame->ecode, stack.currentFrame->eptrb, 0); 1827 1847 if (is_match) 1828 1848 RRETURN; 1829 if ( frame->eptr-- == frame->pp)1849 if (stack.currentFrame->eptr-- == stack.currentFrame->pp) 1830 1850 break; /* Stop if tried at original pos */ 1831 BACKCHAR( frame->eptr);1851 BACKCHAR(stack.currentFrame->eptr); 1832 1852 } 1833 1853 … … 1868 1888 here; that is handled in the code for KET. */ 1869 1889 1870 ASSERT(* frame->ecode > OP_BRA);1871 1872 frame->number = *frame->ecode - OP_BRA;1890 ASSERT(*stack.currentFrame->ecode > OP_BRA); 1891 1892 stack.currentFrame->number = *stack.currentFrame->ecode - OP_BRA; 1873 1893 1874 1894 /* For extended extraction brackets (large number), we have to fish out the 1875 1895 number from a dummy opcode at the start. */ 1876 1896 1877 if ( frame->number > EXTRACT_BASIC_MAX)1878 frame->number = GET2(frame->ecode, 2+LINK_SIZE);1879 frame->offset = frame->number << 1;1897 if (stack.currentFrame->number > EXTRACT_BASIC_MAX) 1898 stack.currentFrame->number = GET2(stack.currentFrame->ecode, 2+LINK_SIZE); 1899 stack.currentFrame->offset = stack.currentFrame->number << 1; 1880 1900 1881 1901 #ifdef DEBUG 1882 printf("start bracket %d subject=", frame->number);1883 pchars( frame->eptr, 16, true, md);1902 printf("start bracket %d subject=", stack.currentFrame->number); 1903 pchars(stack.currentFrame->eptr, 16, true, md); 1884 1904 printf("\n"); 1885 1905 #endif 1886 1906 1887 if ( frame->offset < md->offset_max) {1888 frame->save_offset1 = md->offset_vector[frame->offset];1889 frame->save_offset2 = md->offset_vector[frame->offset + 1];1890 frame->save_offset3 = md->offset_vector[md->offset_end - frame->number];1891 1892 DPRINTF(("saving %d %d %d\n", frame->save_offset1, frame->save_offset2, frame->save_offset3));1893 md->offset_vector[md->offset_end - frame->number] = frame->eptr - md->start_subject;1907 if (stack.currentFrame->offset < md->offset_max) { 1908 stack.currentFrame->save_offset1 = md->offset_vector[stack.currentFrame->offset]; 1909 stack.currentFrame->save_offset2 = md->offset_vector[stack.currentFrame->offset + 1]; 1910 stack.currentFrame->save_offset3 = md->offset_vector[md->offset_end - stack.currentFrame->number]; 1911 1912 DPRINTF(("saving %d %d %d\n", stack.currentFrame->save_offset1, stack.currentFrame->save_offset2, stack.currentFrame->save_offset3)); 1913 md->offset_vector[md->offset_end - stack.currentFrame->number] = stack.currentFrame->eptr - md->start_subject; 1894 1914 1895 1915 do { 1896 RMATCH(1, frame->ecode + 1 + LINK_SIZE, frame->eptrb, match_isgroup);1916 RMATCH(1, stack.currentFrame->ecode + 1 + LINK_SIZE, stack.currentFrame->eptrb, match_isgroup); 1897 1917 if (is_match) RRETURN; 1898 frame->ecode += GET(frame->ecode, 1);1899 } while (* frame->ecode == OP_ALT);1900 1901 DPRINTF(("bracket %d failed\n", frame->number));1902 1903 md->offset_vector[ frame->offset] = frame->save_offset1;1904 md->offset_vector[ frame->offset + 1] = frame->save_offset2;1905 md->offset_vector[md->offset_end - frame->number] = frame->save_offset3;1918 stack.currentFrame->ecode += GET(stack.currentFrame->ecode, 1); 1919 } while (*stack.currentFrame->ecode == OP_ALT); 1920 1921 DPRINTF(("bracket %d failed\n", stack.currentFrame->number)); 1922 1923 md->offset_vector[stack.currentFrame->offset] = stack.currentFrame->save_offset1; 1924 md->offset_vector[stack.currentFrame->offset + 1] = stack.currentFrame->save_offset2; 1925 md->offset_vector[md->offset_end - stack.currentFrame->number] = stack.currentFrame->save_offset3; 1906 1926 1907 1927 RRETURN; … … 1924 1944 1925 1945 RRETURN_SWITCH: 1926 switch ( frame->where)1946 switch (stack.currentFrame->where) 1927 1947 { 1928 1948 case 0: goto RETURN; … … 1967 1987 RETURN: 1968 1988 return is_match ? MATCH_MATCH : MATCH_NOMATCH; 1969 1970 RETURN_ERROR:1971 while (!(frame >= stackframes && frame < stackframesend)) {1972 newframe = frame->prevframe;1973 delete frame;1974 frame = newframe;1975 }1976 return i;1977 1989 } 1978 1990
Note:
See TracChangeset
for help on using the changeset viewer.
